rsomics-annotation 0.1.0

Typed GFF3 and GTF validation, selection, conversion, and sequence extraction
Documentation
use std::fs;
use std::path::{Path, PathBuf};
use std::process::{Command, Output};

use tempfile::tempdir;

fn binary() -> Command {
    Command::new(env!("CARGO_BIN_EXE_rsomics-annotation"))
}

fn write(path: &Path, contents: &str) {
    fs::write(path, contents).unwrap();
}

fn run(command: &mut Command) -> Output {
    command.output().unwrap()
}

fn gff3() -> &'static str {
    "##gff-version 3\n\
     chr1\tsrc\tgene\t1\t30\t.\t+\t.\tID=g1;Name=Gene1\n\
     chr1\tsrc\tmRNA\t1\t30\t.\t+\t.\tID=t1;Parent=g1\n\
     chr1\tsrc\texon\t1\t10\t.\t+\t.\tID=e1;Parent=t1\n\
     chr1\tsrc\texon\t20\t30\t.\t+\t.\tID=e2;Parent=t1\n"
}

fn paths() -> (tempfile::TempDir, PathBuf, PathBuf) {
    let directory = tempdir().unwrap();
    let input = directory.path().join("input.gff3");
    let output = directory.path().join("output.txt");
    write(&input, gff3());
    (directory, input, output)
}

#[test]
fn validates_gff3_and_gtf() {
    let (_directory, input, _) = paths();
    let output = run(binary()
        .arg("validate")
        .arg("--format")
        .arg("gff3")
        .arg(&input));
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );

    let directory = tempdir().unwrap();
    let gtf = directory.path().join("input.gtf");
    write(
        &gtf,
        "chr1\tsrc\ttranscript\t1\t30\t.\t+\t.\tgene_id \"g1\"; transcript_id \"t1\";\n\
         chr1\tsrc\texon\t1\t10\t.\t+\t.\tgene_id \"g1\"; transcript_id \"t1\";\n",
    );
    let output = run(binary().arg("validate").arg("--format").arg("gtf").arg(gtf));
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
}

#[test]
fn validation_failure_is_loud_and_plain() {
    let directory = tempdir().unwrap();
    let input = directory.path().join("bad.gff3");
    write(
        &input,
        "##gff-version 3\nchr1\tsrc\texon\t1\t2\t.\t+\t.\tParent=missing\n",
    );
    let output = run(binary()
        .arg("validate")
        .arg("--format")
        .arg("gff3")
        .arg(input));
    assert!(!output.status.success());
    let stderr = String::from_utf8(output.stderr).unwrap();
    assert!(stderr.contains("line 2"), "{stderr}");
    assert!(stderr.contains("does not resolve"), "{stderr}");
    assert!(!stderr.contains("\u{1b}["), "{stderr:?}");
}

#[test]
fn view_combines_type_attribute_and_region() {
    let (_directory, input, output_path) = paths();
    let output = run(binary()
        .arg("view")
        .arg("--format")
        .arg("gff3")
        .arg(&input)
        .arg("--output")
        .arg(&output_path)
        .arg("--type")
        .arg("exon")
        .arg("--attribute")
        .arg("Parent=t1")
        .arg("--region")
        .arg("chr1:10-20"));
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    let selected = fs::read_to_string(output_path).unwrap();
    assert!(selected.starts_with("##gff-version 3\n"), "{selected}");
    assert!(selected.contains("ID=e1"), "{selected}");
    assert!(selected.contains("ID=e2"), "{selected}");
    assert!(!selected.contains("ID=g1"), "{selected}");
}

#[test]
fn to_bed_uses_checked_half_open_boundary() {
    let directory = tempdir().unwrap();
    let input = directory.path().join("one.gff3");
    let output_path = directory.path().join("one.bed");
    write(
        &input,
        "##gff-version 3\nchr1\tsrc\tgene\t1\t1\t.\t+\t.\tID=g1\n",
    );
    let output = run(binary()
        .arg("to-bed")
        .arg("--format")
        .arg("gff3")
        .arg(input)
        .arg("--output")
        .arg(&output_path));
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    assert_eq!(
        fs::read_to_string(output_path).unwrap(),
        "chr1\t0\t1\tg1\t0\t+\n"
    );
}

#[test]
fn failed_named_output_is_transactional() {
    let directory = tempdir().unwrap();
    let input = directory.path().join("bad.gff3");
    let output_path = directory.path().join("output.gff3");
    write(
        &input,
        "##gff-version 3\n\
         chr1\tsrc\tgene\t1\t2\t.\t+\t.\tID=g1\n\
         chr1\tsrc\tgene\tBAD\t3\t.\t+\t.\tID=g2\n",
    );
    write(&output_path, "original\n");
    let output = run(binary()
        .arg("view")
        .arg("--format")
        .arg("gff3")
        .arg(input)
        .arg("--output")
        .arg(&output_path));
    assert!(!output.status.success());
    assert_eq!(fs::read_to_string(output_path).unwrap(), "original\n");
}

#[cfg(unix)]
#[test]
fn output_aliases_never_modify_input() {
    use std::os::unix::fs::symlink;

    for alias in ["normalized", "hardlink", "symlink"] {
        let (directory, input, _) = paths();
        let output_path = match alias {
            "normalized" => directory.path().join(".").join("input.gff3"),
            "hardlink" => {
                let path = directory.path().join("hardlink.gff3");
                fs::hard_link(&input, &path).unwrap();
                path
            }
            "symlink" => {
                let path = directory.path().join("symlink.gff3");
                symlink(&input, &path).unwrap();
                path
            }
            _ => unreachable!(),
        };
        let original = fs::read(&input).unwrap();
        let output = run(binary()
            .arg("view")
            .arg("--format")
            .arg("gff3")
            .arg(&input)
            .arg("--output")
            .arg(output_path));
        assert!(!output.status.success(), "alias={alias}");
        assert_eq!(fs::read(input).unwrap(), original, "alias={alias}");
    }
}

#[test]
fn json_requires_a_named_data_output() {
    let (_directory, input, _) = paths();
    let output = run(binary()
        .arg("--json")
        .arg("view")
        .arg("--format")
        .arg("gff3")
        .arg(input));
    assert!(!output.status.success());
    let envelope: serde_json::Value = serde_json::from_slice(&output.stderr).unwrap();
    assert_eq!(envelope["status"], "error");
}

#[test]
fn invalid_cli_exits_with_status_two() {
    let output = run(binary().arg("view").arg("--format").arg("unknown"));
    assert_eq!(output.status.code(), Some(2));
}