@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/yamllint_compat_document_start.rs

@@ -1,136 +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 document_start_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let missing = dir.path().join("missing.yaml");
-    fs::write(&missing, "foo: bar\n").unwrap();
-
-    let explicit = dir.path().join("explicit.yaml");
-    fs::write(&explicit, "---\nfoo: bar\n").unwrap();
-
-    let require_cfg = dir.path().join("require.yml");
-    fs::write(
-        &require_cfg,
-        "rules:\n  document-start:\n    level: error\n    present: true\n",
-    )
-    .unwrap();
-
-    let forbid_cfg = dir.path().join("forbid.yml");
-    fs::write(
-        &forbid_cfg,
-        "rules:\n  document-start:\n    level: error\n    present: false\n",
-    )
-    .unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    for scenario in SCENARIOS {
-        let mut ryl_require = build_ryl_command(exe, scenario.ryl_format);
-        ryl_require.arg("-c").arg(&require_cfg).arg(&missing);
-        let (ryl_req_code, ryl_req_msg) = capture_with_env(ryl_require, scenario.envs);
-
-        let mut yam_require = build_yamllint_command(scenario.yam_format);
-        yam_require.arg("-c").arg(&require_cfg).arg(&missing);
-        let (yam_req_code, yam_req_msg) = capture_with_env(yam_require, scenario.envs);
-
-        assert_eq!(ryl_req_code, 1, "ryl require exit ({})", scenario.label);
-        assert_eq!(
-            yam_req_code, 1,
-            "yamllint require exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_req_msg, yam_req_msg,
-            "missing marker diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_require_ok = build_ryl_command(exe, scenario.ryl_format);
-        ryl_require_ok.arg("-c").arg(&require_cfg).arg(&explicit);
-        let (ryl_req_ok_code, ryl_req_ok_msg) =
-            capture_with_env(ryl_require_ok, scenario.envs);
-
-        let mut yam_require_ok = build_yamllint_command(scenario.yam_format);
-        yam_require_ok.arg("-c").arg(&require_cfg).arg(&explicit);
-        let (yam_req_ok_code, yam_req_ok_msg) =
-            capture_with_env(yam_require_ok, scenario.envs);
-
-        assert_eq!(
-            ryl_req_ok_code, 0,
-            "ryl require pass exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_req_ok_code, 0,
-            "yamllint require pass exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_req_ok_msg, yam_req_ok_msg,
-            "require pass diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_forbid = build_ryl_command(exe, scenario.ryl_format);
-        ryl_forbid.arg("-c").arg(&forbid_cfg).arg(&explicit);
-        let (ryl_forbid_code, ryl_forbid_msg) =
-            capture_with_env(ryl_forbid, scenario.envs);
-
-        let mut yam_forbid = build_yamllint_command(scenario.yam_format);
-        yam_forbid.arg("-c").arg(&forbid_cfg).arg(&explicit);
-        let (yam_forbid_code, yam_forbid_msg) =
-            capture_with_env(yam_forbid, scenario.envs);
-
-        assert_eq!(ryl_forbid_code, 1, "ryl forbid exit ({})", scenario.label);
-        assert_eq!(
-            yam_forbid_code, 1,
-            "yamllint forbid exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_forbid_msg, yam_forbid_msg,
-            "forbid diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_forbid_ok = build_ryl_command(exe, scenario.ryl_format);
-        ryl_forbid_ok.arg("-c").arg(&forbid_cfg).arg(&missing);
-        let (ryl_forbid_ok_code, ryl_forbid_ok_msg) =
-            capture_with_env(ryl_forbid_ok, scenario.envs);
-
-        let mut yam_forbid_ok = build_yamllint_command(scenario.yam_format);
-        yam_forbid_ok.arg("-c").arg(&forbid_cfg).arg(&missing);
-        let (yam_forbid_ok_code, yam_forbid_ok_msg) =
-            capture_with_env(yam_forbid_ok, scenario.envs);
-
-        assert_eq!(
-            ryl_forbid_ok_code, 0,
-            "ryl forbid pass exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_forbid_ok_code, 0,
-            "yamllint forbid pass exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_forbid_ok_msg, yam_forbid_ok_msg,
-            "forbid pass diagnostics mismatch ({})",
-            scenario.label
-        );
-    }
-}

package/tests/yamllint_compat_empty_lines.rs

@@ -1,117 +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 {
-    label: &'static str,
-    config: std::path::PathBuf,
-    target: std::path::PathBuf,
-    expected_exit: i32,
-}
-
-#[test]
-fn empty_lines_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let interior_file = dir.path().join("interior.yaml");
-    fs::write(&interior_file, "key: 1\n\n\nvalue: 2\n").unwrap();
-    let start_file = dir.path().join("start.yaml");
-    fs::write(&start_file, "\n\nkey: 1\n").unwrap();
-    let end_file = dir.path().join("end.yaml");
-    fs::write(&end_file, "key: 1\n\n\n").unwrap();
-
-    let interior_cfg = dir.path().join("interior.yml");
-    fs::write(
-        &interior_cfg,
-        "rules:\n  document-start: disable\n  new-line-at-end-of-file: disable\n  empty-lines:\n    max: 1\n    max-start: 0\n    max-end: 0\n",
-    )
-    .unwrap();
-
-    let warning_cfg = dir.path().join("warning.yml");
-    fs::write(
-        &warning_cfg,
-        "rules:\n  document-start: disable\n  new-line-at-end-of-file: disable\n  empty-lines:\n    level: warning\n    max: 1\n    max-start: 0\n    max-end: 0\n",
-    )
-    .unwrap();
-
-    let start_cfg = dir.path().join("start.yml");
-    fs::write(
-        &start_cfg,
-        "rules:\n  document-start: disable\n  new-line-at-end-of-file: disable\n  empty-lines:\n    max: 5\n    max-start: 1\n    max-end: 5\n",
-    )
-    .unwrap();
-
-    let end_cfg = dir.path().join("end.yml");
-    fs::write(
-        &end_cfg,
-        "rules:\n  document-start: disable\n  new-line-at-end-of-file: disable\n  empty-lines:\n    max: 5\n    max-start: 5\n    max-end: 1\n",
-    )
-    .unwrap();
-
-    let cases = vec![
-        Case {
-            label: "interior-error",
-            config: interior_cfg.clone(),
-            target: interior_file.clone(),
-            expected_exit: 1,
-        },
-        Case {
-            label: "interior-warning",
-            config: warning_cfg.clone(),
-            target: interior_file,
-            expected_exit: 0,
-        },
-        Case {
-            label: "start-error",
-            config: start_cfg.clone(),
-            target: start_file,
-            expected_exit: 1,
-        },
-        Case {
-            label: "end-error",
-            config: end_cfg.clone(),
-            target: end_file,
-            expected_exit: 1,
-        },
-    ];
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    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.target);
-            let (ryl_code, ryl_output) = 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.target);
-            let (yam_code, yam_output) = capture_with_env(yam_cmd, scenario.envs);
-
-            assert_eq!(
-                ryl_code, case.expected_exit,
-                "ryl exit mismatch ({}/{})",
-                scenario.label, case.label
-            );
-            assert_eq!(
-                yam_code, case.expected_exit,
-                "yamllint exit mismatch ({}/{})",
-                scenario.label, case.label
-            );
-            assert_eq!(
-                ryl_output, yam_output,
-                "diagnostics mismatch ({}/{})",
-                scenario.label, case.label
-            );
-        }
-    }
-}

package/tests/yamllint_compat_empty_values.rs

@@ -1,179 +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 empty_values_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let violations = dir.path().join("violations.yaml");
-    fs::write(
-        &violations,
-        "block:\n  missing:\nflow: { missing: }\nseq:\n  -\n",
-    )
-    .unwrap();
-
-    let clean = dir.path().join("clean.yaml");
-    fs::write(
-        &clean,
-        "block:\n  present: value\nflow: { present: value }\nseq:\n  - value\n",
-    )
-    .unwrap();
-
-    let all_cfg = dir.path().join("empty-all.yml");
-    fs::write(
-        &all_cfg,
-        "rules:\n  document-start: disable\n  empty-values: enable\n",
-    )
-    .unwrap();
-
-    let block_cfg = dir.path().join("empty-block.yml");
-    fs::write(
-        &block_cfg,
-        "rules:\n  document-start: disable\n  empty-values:\n    forbid-in-block-mappings: true\n    forbid-in-flow-mappings: false\n    forbid-in-block-sequences: false\n",
-    )
-    .unwrap();
-
-    let flow_cfg = dir.path().join("empty-flow.yml");
-    fs::write(
-        &flow_cfg,
-        "rules:\n  document-start: disable\n  empty-values:\n    forbid-in-block-mappings: false\n    forbid-in-flow-mappings: true\n    forbid-in-block-sequences: false\n",
-    )
-    .unwrap();
-
-    let seq_cfg = dir.path().join("empty-seq.yml");
-    fs::write(
-        &seq_cfg,
-        "rules:\n  document-start: disable\n  empty-values:\n    forbid-in-block-mappings: false\n    forbid-in-flow-mappings: false\n    forbid-in-block-sequences: true\n",
-    )
-    .unwrap();
-
-    let none_cfg = dir.path().join("empty-none.yml");
-    fs::write(
-        &none_cfg,
-        "rules:\n  document-start: disable\n  empty-values:\n    forbid-in-block-mappings: false\n    forbid-in-flow-mappings: false\n    forbid-in-block-sequences: false\n",
-    )
-    .unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    for scenario in SCENARIOS {
-        let mut ryl_all = build_ryl_command(exe, scenario.ryl_format);
-        ryl_all.arg("-c").arg(&all_cfg).arg(&violations);
-        let (ryl_all_code, ryl_all_msg) = capture_with_env(ryl_all, scenario.envs);
-
-        let mut yam_all = build_yamllint_command(scenario.yam_format);
-        yam_all.arg("-c").arg(&all_cfg).arg(&violations);
-        let (yam_all_code, yam_all_msg) = capture_with_env(yam_all, scenario.envs);
-
-        assert_eq!(ryl_all_code, 1, "ryl all exit ({})", scenario.label);
-        assert_eq!(yam_all_code, 1, "yamllint all exit ({})", scenario.label);
-        assert_eq!(
-            ryl_all_msg, yam_all_msg,
-            "all diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_block = build_ryl_command(exe, scenario.ryl_format);
-        ryl_block.arg("-c").arg(&block_cfg).arg(&violations);
-        let (ryl_block_code, ryl_block_msg) =
-            capture_with_env(ryl_block, scenario.envs);
-
-        let mut yam_block = build_yamllint_command(scenario.yam_format);
-        yam_block.arg("-c").arg(&block_cfg).arg(&violations);
-        let (yam_block_code, yam_block_msg) =
-            capture_with_env(yam_block, scenario.envs);
-
-        assert_eq!(ryl_block_code, 1, "ryl block exit ({})", scenario.label);
-        assert_eq!(
-            yam_block_code, 1,
-            "yamllint block exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_block_msg, yam_block_msg,
-            "block diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_flow = build_ryl_command(exe, scenario.ryl_format);
-        ryl_flow.arg("-c").arg(&flow_cfg).arg(&violations);
-        let (ryl_flow_code, ryl_flow_msg) = capture_with_env(ryl_flow, scenario.envs);
-
-        let mut yam_flow = build_yamllint_command(scenario.yam_format);
-        yam_flow.arg("-c").arg(&flow_cfg).arg(&violations);
-        let (yam_flow_code, yam_flow_msg) = capture_with_env(yam_flow, scenario.envs);
-
-        assert_eq!(ryl_flow_code, 1, "ryl flow exit ({})", scenario.label);
-        assert_eq!(yam_flow_code, 1, "yamllint flow exit ({})", scenario.label);
-        assert_eq!(
-            ryl_flow_msg, yam_flow_msg,
-            "flow diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_seq = build_ryl_command(exe, scenario.ryl_format);
-        ryl_seq.arg("-c").arg(&seq_cfg).arg(&violations);
-        let (ryl_seq_code, ryl_seq_msg) = capture_with_env(ryl_seq, scenario.envs);
-
-        let mut yam_seq = build_yamllint_command(scenario.yam_format);
-        yam_seq.arg("-c").arg(&seq_cfg).arg(&violations);
-        let (yam_seq_code, yam_seq_msg) = capture_with_env(yam_seq, scenario.envs);
-
-        assert_eq!(ryl_seq_code, 1, "ryl seq exit ({})", scenario.label);
-        assert_eq!(yam_seq_code, 1, "yamllint seq exit ({})", scenario.label);
-        assert_eq!(
-            ryl_seq_msg, yam_seq_msg,
-            "seq diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_none = build_ryl_command(exe, scenario.ryl_format);
-        ryl_none.arg("-c").arg(&none_cfg).arg(&violations);
-        let (ryl_none_code, ryl_none_msg) = capture_with_env(ryl_none, scenario.envs);
-
-        let mut yam_none = build_yamllint_command(scenario.yam_format);
-        yam_none.arg("-c").arg(&none_cfg).arg(&violations);
-        let (yam_none_code, yam_none_msg) = capture_with_env(yam_none, scenario.envs);
-
-        assert_eq!(ryl_none_code, 0, "ryl none exit ({})", scenario.label);
-        assert_eq!(yam_none_code, 0, "yamllint none exit ({})", scenario.label);
-        assert_eq!(
-            ryl_none_msg, yam_none_msg,
-            "none diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_clean = build_ryl_command(exe, scenario.ryl_format);
-        ryl_clean.arg("-c").arg(&all_cfg).arg(&clean);
-        let (ryl_clean_code, ryl_clean_msg) =
-            capture_with_env(ryl_clean, scenario.envs);
-
-        let mut yam_clean = build_yamllint_command(scenario.yam_format);
-        yam_clean.arg("-c").arg(&all_cfg).arg(&clean);
-        let (yam_clean_code, yam_clean_msg) =
-            capture_with_env(yam_clean, scenario.envs);
-
-        assert_eq!(ryl_clean_code, 0, "ryl clean exit ({})", scenario.label);
-        assert_eq!(
-            yam_clean_code, 0,
-            "yamllint clean exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_clean_msg, yam_clean_msg,
-            "clean diagnostics mismatch ({})",
-            scenario.label
-        );
-    }
-}

package/tests/yamllint_compat_float_values.rs

@@ -1,216 +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 float_values_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let violations = dir.path().join("violations.yaml");
-    fs::write(&violations, "a: .5\nb: 1e2\nc: .nan\nd: .inf\n").unwrap();
-
-    let ok = dir.path().join("ok.yaml");
-    fs::write(&ok, "a: 0.5\nb: 10.0\nc: 0.0\n").unwrap();
-
-    let default_cfg = dir.path().join("float-default.yml");
-    fs::write(
-        &default_cfg,
-        "rules:\n  document-start: disable\n  float-values: enable\n",
-    )
-    .unwrap();
-
-    let require_cfg = dir.path().join("float-require.yml");
-    fs::write(
-        &require_cfg,
-        "rules:\n  document-start: disable\n  float-values:\n    require-numeral-before-decimal: true\n",
-    )
-    .unwrap();
-
-    let scientific_cfg = dir.path().join("float-scientific.yml");
-    fs::write(
-        &scientific_cfg,
-        "rules:\n  document-start: disable\n  float-values:\n    forbid-scientific-notation: true\n",
-    )
-    .unwrap();
-
-    let nan_cfg = dir.path().join("float-nan.yml");
-    fs::write(
-        &nan_cfg,
-        "rules:\n  document-start: disable\n  float-values:\n    forbid-nan: true\n",
-    )
-    .unwrap();
-
-    let inf_cfg = dir.path().join("float-inf.yml");
-    fs::write(
-        &inf_cfg,
-        "rules:\n  document-start: disable\n  float-values:\n    forbid-inf: true\n",
-    )
-    .unwrap();
-
-    let all_cfg = dir.path().join("float-all.yml");
-    fs::write(
-        &all_cfg,
-        "rules:\n  document-start: disable\n  float-values:\n    require-numeral-before-decimal: true\n    forbid-scientific-notation: true\n    forbid-nan: true\n    forbid-inf: true\n",
-    )
-    .unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    for scenario in SCENARIOS {
-        // Default configuration should not flag anything
-        let mut ryl_default = build_ryl_command(exe, scenario.ryl_format);
-        ryl_default.arg("-c").arg(&default_cfg).arg(&violations);
-        let (ryl_default_code, ryl_default_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(&violations);
-        let (yam_default_code, yam_default_msg) =
-            capture_with_env(yam_default, scenario.envs);
-
-        assert_eq!(ryl_default_code, 0, "ryl default exit ({})", scenario.label);
-        assert_eq!(
-            yam_default_code, 0,
-            "yamllint default exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_default_msg, yam_default_msg,
-            "default diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // require-numeral-before-decimal
-        let mut ryl_require = build_ryl_command(exe, scenario.ryl_format);
-        ryl_require.arg("-c").arg(&require_cfg).arg(&violations);
-        let (ryl_require_code, ryl_require_msg) =
-            capture_with_env(ryl_require, scenario.envs);
-
-        let mut yam_require = build_yamllint_command(scenario.yam_format);
-        yam_require.arg("-c").arg(&require_cfg).arg(&violations);
-        let (yam_require_code, yam_require_msg) =
-            capture_with_env(yam_require, scenario.envs);
-
-        assert_eq!(ryl_require_code, 1, "ryl require exit ({})", scenario.label);
-        assert_eq!(
-            yam_require_code, 1,
-            "yamllint require exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_require_msg, yam_require_msg,
-            "require diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // forbid-scientific-notation
-        let mut ryl_scientific = build_ryl_command(exe, scenario.ryl_format);
-        ryl_scientific
-            .arg("-c")
-            .arg(&scientific_cfg)
-            .arg(&violations);
-        let (ryl_scientific_code, ryl_scientific_msg) =
-            capture_with_env(ryl_scientific, scenario.envs);
-
-        let mut yam_scientific = build_yamllint_command(scenario.yam_format);
-        yam_scientific
-            .arg("-c")
-            .arg(&scientific_cfg)
-            .arg(&violations);
-        let (yam_scientific_code, yam_scientific_msg) =
-            capture_with_env(yam_scientific, scenario.envs);
-
-        assert_eq!(
-            ryl_scientific_code, 1,
-            "ryl scientific exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_scientific_code, 1,
-            "yamllint scientific exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_scientific_msg, yam_scientific_msg,
-            "scientific diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // forbid-nan
-        let mut ryl_nan = build_ryl_command(exe, scenario.ryl_format);
-        ryl_nan.arg("-c").arg(&nan_cfg).arg(&violations);
-        let (ryl_nan_code, ryl_nan_msg) = capture_with_env(ryl_nan, scenario.envs);
-
-        let mut yam_nan = build_yamllint_command(scenario.yam_format);
-        yam_nan.arg("-c").arg(&nan_cfg).arg(&violations);
-        let (yam_nan_code, yam_nan_msg) = capture_with_env(yam_nan, scenario.envs);
-
-        assert_eq!(ryl_nan_code, 1, "ryl nan exit ({})", scenario.label);
-        assert_eq!(yam_nan_code, 1, "yamllint nan exit ({})", scenario.label);
-        assert_eq!(
-            ryl_nan_msg, yam_nan_msg,
-            "nan diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // forbid-inf
-        let mut ryl_inf = build_ryl_command(exe, scenario.ryl_format);
-        ryl_inf.arg("-c").arg(&inf_cfg).arg(&violations);
-        let (ryl_inf_code, ryl_inf_msg) = capture_with_env(ryl_inf, scenario.envs);
-
-        let mut yam_inf = build_yamllint_command(scenario.yam_format);
-        yam_inf.arg("-c").arg(&inf_cfg).arg(&violations);
-        let (yam_inf_code, yam_inf_msg) = capture_with_env(yam_inf, scenario.envs);
-
-        assert_eq!(ryl_inf_code, 1, "ryl inf exit ({})", scenario.label);
-        assert_eq!(yam_inf_code, 1, "yamllint inf exit ({})", scenario.label);
-        assert_eq!(
-            ryl_inf_msg, yam_inf_msg,
-            "inf diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // all options enabled, expect four diagnostics, and ok file passes
-        let mut ryl_all = build_ryl_command(exe, scenario.ryl_format);
-        ryl_all.arg("-c").arg(&all_cfg).arg(&violations);
-        let (ryl_all_code, ryl_all_msg) = capture_with_env(ryl_all, scenario.envs);
-
-        let mut yam_all = build_yamllint_command(scenario.yam_format);
-        yam_all.arg("-c").arg(&all_cfg).arg(&violations);
-        let (yam_all_code, yam_all_msg) = capture_with_env(yam_all, scenario.envs);
-
-        assert_eq!(ryl_all_code, 1, "ryl all exit ({})", scenario.label);
-        assert_eq!(yam_all_code, 1, "yamllint all exit ({})", scenario.label);
-        assert_eq!(
-            ryl_all_msg, yam_all_msg,
-            "all diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_ok = build_ryl_command(exe, scenario.ryl_format);
-        ryl_ok.arg("-c").arg(&all_cfg).arg(&ok);
-        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(&all_cfg).arg(&ok);
-        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
-        );
-    }
-}