@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/cli_config_migrate.rs

@@ -1,229 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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}"
-    );
-}