drep-ai 3.0.0

//! Output-sink behaviour: `doctor` is diagnosis and must not turn a writer
//! failure into a gate failure.

use crate::cli::doctor::{DoctorArgs, classify_output};

/// A sink that refuses every write with `BrokenPipe`, as a closed pipe does.
struct ClosedPipe;

impl std::io::Write for ClosedPipe {
    fn write(&mut self, _buf: &[u8]) -> std::io::Result<usize> {
        Err(std::io::Error::new(
            std::io::ErrorKind::BrokenPipe,
            "closed",
        ))
    }
    fn flush(&mut self) -> std::io::Result<()> {
        Ok(())
    }
}

/// A sink that fails with something that is *not* a broken pipe.
struct BadDisk;

impl std::io::Write for BadDisk {
    fn write(&mut self, _buf: &[u8]) -> std::io::Result<usize> {
        Err(std::io::Error::other("disk on fire"))
    }
    fn flush(&mut self) -> std::io::Result<()> {
        Ok(())
    }
}

/// `drep doctor | head -5` closes the pipe under us. That is the reader's
/// choice, not a diagnostic failure - and `main.rs` maps any `Err` to exit 2,
/// so letting it through would contradict this command's one contract.
///
/// The `BadDisk` half is what makes the classification meaningful: without it,
/// "treat every write error as success" passes, and a genuinely failed report
/// would be indistinguishable from a delivered one.
#[tokio::test]
async fn a_closed_pipe_is_not_a_failure_but_a_real_write_error_is() {
    let dir = tempfile::tempdir().expect("tempdir");
    std::fs::write(dir.path().join("a.py"), "x = 1\n").expect("a.py");
    let args = DoctorArgs {
        path: dir.path().to_path_buf(),
        config: None,
    };

    let mut sink = ClosedPipe;
    let pipe_result = super::run_scoped(&mut sink, &args, dir.path()).await;
    assert_eq!(
        classify_output(pipe_result).expect("a closed pipe is clean"),
        crate::Exit::Clean
    );

    let mut sink = BadDisk;
    let disk_result = super::run_scoped(&mut sink, &args, dir.path()).await;
    assert!(
        classify_output(disk_result).is_err(),
        "a real output failure must not be classified as success"
    );
}