GitCorner

Code

ossartcraftcraftanything🌐
642d5a256791
use craft_anything_engine::Target;
use craft_anything_engine::evidence::ErrorCode;
use craft_anything_engine::tools::static_input;
#[cfg(unix)]
use craft_anything_engine::{Caller, CancelToken, Ctx};

#[cfg(target_os = "linux")]
#[test]
fn text_tool_refuses_a_pipe_without_waiting_for_its_writer() {
    use craft_anything_engine::{CallOptions, Engine};
    use std::os::fd::AsRawFd;
    use std::sync::mpsc;
    use std::time::Duration;

    let (reader, writer) = std::io::pipe().unwrap();
    let path = format!("/proc/self/fd/{}", reader.as_raw_fd());
    let (sender, receiver) = mpsc::channel();
    let worker = std::thread::spawn(move || {
        let engine = Engine::new(craft_anything_engine::testing::session());
        let result = engine.call("core_text_read", serde_json::json!({"path": path}), CallOptions::new(Caller::Cli));
        drop(reader);
        sender.send(result).ok();
    });
    let immediate = receiver.recv_timeout(Duration::from_secs(1));
    // Release a baseline read waiting for EOF before checking the bounded response.
    drop(writer);
    if immediate.is_err() {
        let _ = receiver.recv_timeout(Duration::from_secs(1));
    }
    if worker.is_finished() {
        worker.join().unwrap();
    }
    let result = immediate.expect("reading a pipe waited for its writer instead of rejecting it");
    assert_eq!(result.unwrap_err().code, ErrorCode::BadInput);
}

#[cfg(target_os = "linux")]
#[test]
fn load_path_checks_actual_bytes_when_metadata_reports_zero() {
    let path = "/proc/self/stat";
    assert_eq!(std::fs::metadata(path).unwrap().len(), 0);
    let result = static_input::load_path(path, 1);
    assert!(result.is_err(), "a one-byte cap accepted {} bytes", result.as_ref().map_or(0, |input| input.bytes.len()));
    assert_eq!(result.unwrap_err().code, ErrorCode::OverLimit);
}

#[cfg(target_os = "linux")]
#[test]
fn prefix_reader_checks_eof_before_hashing_zero_size_metadata() {
    let mut session = craft_anything_engine::testing::session();
    let ctx = Ctx { tool: "test", session: &mut session, cancel: CancelToken::default(), progress: &|_| {}, caller: Caller::Cli };
    for cap in [1, 0] {
        let prefix = static_input::load_prefix(&ctx, Some("/proc/self/stat"), cap).unwrap();
        assert_eq!(prefix.bytes.len(), cap as usize);
        assert_eq!(prefix.file_size, 0, "keep the metadata size rather than guessing a full length");
        assert!(!prefix.whole, "a bounded prefix was reported as the whole virtual file");
        assert!(prefix.subject.sha256.is_none(), "a prefix hash must not identify the whole file");
    }
    let whole = static_input::load_prefix(&ctx, Some("/proc/self/stat"), 16 * 1024).unwrap();
    assert!(!whole.bytes.is_empty());
    assert!(whole.whole);
    assert_eq!(whole.subject.sha256, Some(craft_anything_engine::evidence::sha256_hex(&whole.bytes)));
}

#[cfg(target_os = "linux")]
#[test]
fn archive_input_checks_actual_bytes_when_metadata_reports_zero() {
    use craft_anything_engine::{CallOptions, Engine};
    let engine = Engine::new(craft_anything_engine::testing::session());
    let result = engine.call("core_archive_show", serde_json::json!({"path": "/proc/self/stat", "max_total_bytes": 1}), CallOptions::new(Caller::Cli));
    assert!(result.is_err(), "archive input read beyond its one-byte cap");
    assert_eq!(result.unwrap_err().code, ErrorCode::OverLimit);
}

#[cfg(unix)]
#[test]
fn load_path_refuses_a_non_regular_file() {
    let result = static_input::load_path("/dev/null", 16);
    assert!(result.is_err(), "a character device was accepted as a file");
    assert_eq!(result.unwrap_err().code, ErrorCode::BadInput);
}

#[cfg(unix)]
#[test]
fn prefix_reader_refuses_a_non_regular_file() {
    let mut session = craft_anything_engine::testing::session();
    let ctx = Ctx { tool: "test", session: &mut session, cancel: CancelToken::default(), progress: &|_| {}, caller: Caller::Cli };
    let result = static_input::load_prefix(&ctx, Some("/dev/null"), 16);
    assert!(result.is_err(), "a character device was accepted as a prefix input");
    assert_eq!(result.unwrap_err().code, ErrorCode::BadInput);
}

#[cfg(unix)]
#[test]
fn targets_refuse_a_non_regular_file() {
    let result = Target::load(std::path::Path::new("/dev/null"));
    assert!(result.is_err(), "a character device was accepted as a target");
    assert_eq!(result.unwrap_err().code, ErrorCode::BadInput);
}

#[test]
fn ordinary_files_keep_exact_cap_and_empty_input_support() {
    let directory = craft_anything_engine::testing::temp_dir();
    let path = directory.join("input.bin");
    std::fs::write(&path, b"four").unwrap();
    let path = path.to_str().unwrap();
    assert_eq!(&*static_input::load_path(path, 4).unwrap().bytes, b"four");
    assert_eq!(&*static_input::load_path(path, u64::MAX).unwrap().bytes, b"four");
    assert_eq!(static_input::load_path(path, 3).unwrap_err().code, ErrorCode::OverLimit);
    std::fs::write(path, b"").unwrap();
    assert!(static_input::load_path(path, 0).unwrap().bytes.is_empty());
    assert!(Target::load(&directory).unwrap().bytes.is_empty());
    std::fs::remove_dir_all(directory).unwrap();
}

#[cfg(unix)]
#[test]
fn regular_file_symlinks_and_prefix_reads_keep_working() {
    let directory = craft_anything_engine::testing::temp_dir();
    let path = directory.join("file.bin");
    let link = directory.join("link.bin");
    std::fs::write(&path, b"hello").unwrap();
    std::os::unix::fs::symlink(&path, &link).unwrap();
    let link_name = link.to_str().unwrap();
    assert_eq!(&*static_input::load_path(link_name, 5).unwrap().bytes, b"hello");
    assert_eq!(&*Target::load(&link).unwrap().bytes, b"hello");
    let mut session = craft_anything_engine::testing::session();
    let ctx = Ctx { tool: "test", session: &mut session, cancel: CancelToken::default(), progress: &|_| {}, caller: Caller::Cli };
    let prefix = static_input::load_prefix(&ctx, Some(link_name), 3).unwrap();
    assert_eq!(prefix.bytes, b"hel");
    assert_eq!(prefix.file_size, 5);
    assert!(!prefix.whole);
    assert!(prefix.subject.sha256.is_none());
    let whole = static_input::load_prefix(&ctx, Some(link_name), 5).unwrap();
    assert_eq!(whole.bytes, b"hello");
    assert!(whole.whole);
    assert!(whole.subject.sha256.is_some());
    std::fs::remove_dir_all(directory).unwrap();
}