@owenlamont/ryl 0.4.1

package/tests/cli_config_migrate.rs

@@ -0,0 +1,229 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("failed to run ryl");
+    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)
+}
+
+#[test]
+fn migrate_configs_dry_run_does_not_write_files() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(
+        root.join(".yamllint"),
+        "rules: { document-start: disable }\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .arg("--migrate-configs")
+        .arg("--migrate-root")
+        .arg(root));
+    assert_eq!(code, 0, "stdout={stdout} stderr={stderr}");
+    assert!(stdout.contains(".yamllint ->"));
+    assert!(!root.join(".ryl.toml").exists());
+}
+
+#[test]
+fn migrate_configs_write_with_rename_flattens_extends() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(
+        root.join("base.yaml"),
+        "rules: { truthy: { level: error } }\n",
+    )
+    .unwrap();
+    fs::write(
+        root.join(".yamllint"),
+        "extends: base.yaml\nrules: { document-start: disable }\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .arg("--migrate-configs")
+        .arg("--migrate-root")
+        .arg(root)
+        .arg("--migrate-write")
+        .arg("--migrate-rename-old")
+        .arg(".bak"));
+    assert_eq!(code, 0, "stdout={stdout} stderr={stderr}");
+
+    let toml = fs::read_to_string(root.join(".ryl.toml")).unwrap();
+    assert!(toml.contains("document-start = \"disable\""));
+    assert!(toml.contains("[rules.truthy]"));
+    assert!(toml.contains("level = \"error\""));
+    assert!(!root.join(".yamllint").exists());
+    assert!(root.join(".yamllint.bak").exists());
+}
+
+#[test]
+fn migrate_configs_warns_when_multiple_yaml_configs_share_directory() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(root.join(".yamllint"), "rules: {}\n").unwrap();
+    fs::write(
+        root.join(".yamllint.yml"),
+        "rules: { document-start: disable }\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _stdout, stderr) = run(Command::new(exe)
+        .arg("--migrate-configs")
+        .arg("--migrate-root")
+        .arg(root));
+    assert_eq!(code, 0, "stderr={stderr}");
+    assert!(stderr.contains("warning: skipping lower-precedence config"));
+}
+
+#[test]
+fn migrate_configs_write_with_delete_old_removes_skipped_lower_precedence_files() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    let primary = root.join(".yamllint");
+    let skipped = root.join(".yamllint.yml");
+    fs::write(&primary, "rules: {}\n").unwrap();
+    fs::write(&skipped, "rules: { document-start: disable }\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _stdout, stderr) = run(Command::new(exe)
+        .arg("--migrate-configs")
+        .arg("--migrate-root")
+        .arg(root)
+        .arg("--migrate-write")
+        .arg("--migrate-delete-old"));
+    assert_eq!(code, 0, "stderr={stderr}");
+    assert!(!primary.exists());
+    assert!(!skipped.exists());
+}
+
+#[test]
+fn migrate_configs_write_with_rename_old_renames_skipped_lower_precedence_files() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    let primary = root.join(".yamllint");
+    let skipped = root.join(".yamllint.yml");
+    fs::write(&primary, "rules: {}\n").unwrap();
+    fs::write(&skipped, "rules: { document-start: disable }\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _stdout, stderr) = run(Command::new(exe)
+        .arg("--migrate-configs")
+        .arg("--migrate-root")
+        .arg(root)
+        .arg("--migrate-write")
+        .arg("--migrate-rename-old")
+        .arg(".bak"));
+    assert_eq!(code, 0, "stderr={stderr}");
+    assert!(!primary.exists());
+    assert!(!skipped.exists());
+    assert!(root.join(".yamllint.bak").exists());
+    assert!(root.join(".yamllint.yml.bak").exists());
+}
+
+#[test]
+fn migrate_rename_and_delete_conflict() {
+    let td = tempdir().unwrap();
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _stdout, stderr) = run(Command::new(exe)
+        .arg("--migrate-configs")
+        .arg("--migrate-root")
+        .arg(td.path())
+        .arg("--migrate-write")
+        .arg("--migrate-rename-old")
+        .arg(".bak")
+        .arg("--migrate-delete-old"));
+    assert_eq!(code, 2, "stderr={stderr}");
+    assert!(stderr.contains("cannot be used with"));
+}
+
+#[test]
+fn migrate_delete_old_requires_write() {
+    let td = tempdir().unwrap();
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _stdout, stderr) = run(Command::new(exe)
+        .arg("--migrate-configs")
+        .arg("--migrate-root")
+        .arg(td.path())
+        .arg("--migrate-delete-old"));
+    assert_eq!(code, 2, "stderr={stderr}");
+    assert!(stderr.contains("required"));
+}
+
+#[test]
+fn migrate_options_require_migrate_configs() {
+    let td = tempdir().unwrap();
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _stdout, stderr) = run(Command::new(exe)
+        .arg("--migrate-root")
+        .arg(td.path())
+        .arg(td.path()));
+    assert_eq!(code, 2, "stderr={stderr}");
+    assert!(stderr.contains("--migrate-configs"));
+}
+
+#[test]
+fn migrate_configs_empty_default_root_prints_no_configs_message() {
+    let td = tempdir().unwrap();
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .current_dir(td.path())
+        .arg("--migrate-configs"));
+    assert_eq!(code, 0, "stdout={stdout} stderr={stderr}");
+    assert!(stdout.contains("No legacy YAML config files found under"));
+}
+
+#[test]
+fn migrate_configs_stdout_prints_generated_toml() {
+    let td = tempdir().unwrap();
+    fs::write(
+        td.path().join(".yamllint"),
+        "rules: { document-start: disable }\n",
+    )
+    .unwrap();
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .arg("--migrate-configs")
+        .arg("--migrate-root")
+        .arg(td.path())
+        .arg("--migrate-stdout"));
+    assert_eq!(code, 0, "stdout={stdout} stderr={stderr}");
+    assert!(stdout.contains("# "));
+    assert!(stdout.contains("[rules]"));
+}
+
+#[test]
+fn migrate_configs_write_with_delete_old_removes_source() {
+    let td = tempdir().unwrap();
+    let source = td.path().join(".yamllint");
+    fs::write(&source, "rules: { document-start: disable }\n").unwrap();
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _stdout, stderr) = run(Command::new(exe)
+        .arg("--migrate-configs")
+        .arg("--migrate-root")
+        .arg(td.path())
+        .arg("--migrate-write")
+        .arg("--migrate-delete-old"));
+    assert_eq!(code, 0, "stderr={stderr}");
+    assert!(!source.exists());
+    assert!(td.path().join(".ryl.toml").exists());
+}
+
+#[test]
+fn migrate_configs_missing_root_returns_usage_error() {
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _stdout, stderr) = run(Command::new(exe)
+        .arg("--migrate-configs")
+        .arg("--migrate-root")
+        .arg("/definitely/no/such/ryl/path"));
+    assert_eq!(code, 2, "stderr={stderr}");
+    assert!(stderr.contains("migrate root does not exist"));
+}

package/tests/cli_document_end_rule.rs

@@ -0,0 +1,92 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("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)
+}
+
+#[test]
+fn missing_marker_reports_error() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("missing.yaml");
+    fs::write(&file, "---\nname: value\n").unwrap();
+
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-end:\n    level: error\n    present: true\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(code, 1, "expected error: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("missing document end \"...\""),
+        "missing message: {output}"
+    );
+    assert!(
+        output.contains("document-end"),
+        "rule id missing from output: {output}"
+    );
+}
+
+#[test]
+fn forbidding_marker_flags_explicit_document() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("explicit.yaml");
+    fs::write(&file, "---\nname: value\n...\n").unwrap();
+
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-end:\n    level: error\n    present: false\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(code, 1, "expected error: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("found forbidden document end \"...\""),
+        "missing forbidden message: {output}"
+    );
+    assert!(
+        output.contains("document-end"),
+        "rule id missing from output: {output}"
+    );
+}
+
+#[test]
+fn forbidding_marker_allows_implicit_document() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("implicit.yaml");
+    fs::write(&file, "---\nname: value\n").unwrap();
+
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-end:\n    level: error\n    present: false\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(
+        code, 0,
+        "implicit end should pass: stdout={stdout} stderr={stderr}"
+    );
+    assert!(stdout.trim().is_empty(), "expected no stdout: {stdout}");
+    assert!(stderr.trim().is_empty(), "expected no stderr: {stderr}");
+}

package/tests/cli_document_start_rule.rs

@@ -0,0 +1,92 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("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)
+}
+
+#[test]
+fn missing_marker_reports_error() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("missing.yaml");
+    fs::write(&file, "name: value\n").unwrap();
+
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start:\n    level: error\n    present: true\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(code, 1, "expected error: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("missing document start \"---\""),
+        "missing message: {output}"
+    );
+    assert!(
+        output.contains("document-start"),
+        "rule id missing from output: {output}"
+    );
+}
+
+#[test]
+fn forbidding_marker_flags_explicit_document() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("explicit.yaml");
+    fs::write(&file, "---\nname: value\n").unwrap();
+
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start:\n    level: error\n    present: false\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(code, 1, "expected error: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("found forbidden document start \"---\""),
+        "missing forbidden message: {output}"
+    );
+    assert!(
+        output.contains("document-start"),
+        "rule id missing from output: {output}"
+    );
+}
+
+#[test]
+fn forbidding_marker_allows_implicit_document() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("implicit.yaml");
+    fs::write(&file, "name: value\n").unwrap();
+
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start:\n    level: error\n    present: false\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(
+        code, 0,
+        "implicit start should pass: stdout={stdout} stderr={stderr}"
+    );
+    assert!(stdout.trim().is_empty(), "expected no stdout: {stdout}");
+    assert!(stderr.trim().is_empty(), "expected no stderr: {stderr}");
+}

package/tests/cli_empty_lines_rule.rs

@@ -0,0 +1,87 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("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 command_output<'a>(stdout: &'a str, stderr: &'a str) -> &'a str {
+    if stderr.is_empty() { stdout } else { stderr }
+}
+
+#[test]
+fn reports_interior_blank_run() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("interior.yaml");
+    fs::write(&file, "key: value\n\n\n\nnext: value\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  new-line-at-end-of-file: disable\n  empty-lines:\n    max: 2\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(code, 1, "expected failure: stdout={stdout} stderr={stderr}");
+    let output = command_output(&stdout, &stderr);
+    assert!(
+        output.contains("too many blank lines (3 > 2)"),
+        "missing message: {output}"
+    );
+    assert!(output.contains("empty-lines"), "rule id missing: {output}");
+    assert!(output.contains("4:1"), "incorrect location: {output}");
+}
+
+#[test]
+fn enforces_start_and_end_limits() {
+    let dir = tempdir().unwrap();
+
+    let start_file = dir.path().join("start.yaml");
+    fs::write(&start_file, "\n\nkey: value\n").unwrap();
+    let start_config = dir.path().join("start-config.yml");
+    fs::write(
+        &start_config,
+        "rules:\n  document-start: disable\n  new-line-at-end-of-file: disable\n  empty-lines:\n    max: 5\n    max-start: 1\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .arg("-c")
+        .arg(&start_config)
+        .arg(&start_file));
+    assert_eq!(code, 1, "expected failure: stdout={stdout} stderr={stderr}");
+    let output = command_output(&stdout, &stderr);
+    assert!(
+        output.contains("too many blank lines (2 > 1)"),
+        "missing start message: {output}"
+    );
+    assert!(output.contains("2:1"), "incorrect start location: {output}");
+
+    let end_file = dir.path().join("end.yaml");
+    fs::write(&end_file, "key: value\n\n\n").unwrap();
+    let end_config = dir.path().join("end-config.yml");
+    fs::write(
+        &end_config,
+        "rules:\n  document-start: disable\n  new-line-at-end-of-file: disable\n  empty-lines:\n    max: 5\n    max-end: 1\n",
+    )
+    .unwrap();
+
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&end_config).arg(&end_file));
+    assert_eq!(code, 1, "expected failure: stdout={stdout} stderr={stderr}");
+    let output = command_output(&stdout, &stderr);
+    assert!(
+        output.contains("too many blank lines (2 > 1)"),
+        "missing end message: {output}"
+    );
+    assert!(output.contains("3:1"), "incorrect end location: {output}");
+}

package/tests/cli_empty_values_rule.rs

@@ -0,0 +1,68 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("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)
+}
+
+#[test]
+fn empty_values_reports_all_diagnostics() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("invalid.yaml");
+    fs::write(&file, "block:\n  missing:\nflow: { missing: }\nseq:\n  -\n").unwrap();
+
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  empty-values: enable\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(code, 1, "expected failure: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { &stdout } else { &stderr };
+    assert!(
+        output.contains("empty value in block mapping"),
+        "missing block mapping message: {output}"
+    );
+    assert!(
+        output.contains("empty value in flow mapping"),
+        "missing flow mapping message: {output}"
+    );
+    assert!(
+        output.contains("empty value in block sequence"),
+        "missing block sequence message: {output}"
+    );
+}
+
+#[test]
+fn empty_values_honors_flags() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("ok.yaml");
+    fs::write(&file, "block:\n  missing:\nflow: { missing: }\nseq:\n  -\n").unwrap();
+
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "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");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(
+        code, 0,
+        "expected success when all checks disabled: stdout={stdout} stderr={stderr}"
+    );
+    assert!(stdout.trim().is_empty(), "expected no stdout: {stdout}");
+    assert!(stderr.trim().is_empty(), "expected no stderr: {stderr}");
+}

package/tests/cli_env_config.rs

@@ -0,0 +1,34 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("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)
+}
+
+#[test]
+fn env_config_file_is_honored() {
+    let dir = tempdir().unwrap();
+    let cfg = dir.path().join("env-config.yml");
+    fs::write(
+        &cfg,
+        "rules:\n  new-line-at-end-of-file: disable\n  document-start: disable\n",
+    )
+    .unwrap();
+    let file = dir.path().join("no_newline.yaml");
+    fs::write(&file, "key: value").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .env("YAMLLINT_CONFIG_FILE", cfg.display().to_string())
+        .arg(&file));
+    assert_eq!(
+        code, 0,
+        "env-config should disable rule: stdout={stdout} stderr={stderr}"
+    );
+}

package/tests/cli_exit_and_errors.rs

@@ -0,0 +1,41 @@
+use std::process::Command;
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("failed to run ryl");
+    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)
+}
+
+#[test]
+fn no_arguments_returns_usage_error_code_2() {
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _out, err) = run(&mut Command::new(exe));
+    assert_eq!(code, 2, "expected usage error exit code 2: {err}");
+    assert!(
+        err.contains("expected one or more paths"),
+        "expected usage message in stderr: {err}"
+    );
+}
+
+#[test]
+fn empty_directory_results_in_success() {
+    let dir = tempdir().unwrap();
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _out, err) = run(Command::new(exe).arg(dir.path()));
+    assert_eq!(code, 0, "expected success when no YAML files: {err}");
+}
+
+#[test]
+fn non_existent_file_reports_read_error() {
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let bogus = std::path::Path::new("this/file/does/not/exist.yaml");
+    let (code, _out, err) = run(Command::new(exe).arg(bogus));
+    assert_eq!(code, 1, "expected failure for unreadable file");
+    assert!(
+        err.contains("failed to read"),
+        "expected read error in stderr: {err}"
+    );
+}