rsomics-composition 0.1.0

Compositional-data geometry, transforms, and differential abundance
Documentation
use std::fs;
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::{Command, Output, Stdio};

use tempfile::TempDir;

const TABLE: &str = "sample\ta\tb\tc\ns1\t1\t2\t3\ns2\t2\t3\t5\ns3\t4\t2\t1\n";
const ZERO_TABLE: &str = "sample\ta\tb\tc\ns1\t1\t0\t3\ns2\t0\t3\t5\ns3\t4\t2\t0\n";
const METADATA: &str = "sample\tgroup\ns3\tcase\ns1\tcontrol\ns2\tcontrol\n";
const ANCOM_TABLE: &str = concat!(
    "sample\tb1\tb2\tb3\tb4\tb5\tb6\tb7\n",
    "s1\t12\t11\t10\t10\t10\t10\t10\n",
    "s2\t9\t11\t12\t10\t10\t10\t10\n",
    "s3\t1\t11\t10\t11\t10\t5\t9\n",
    "s4\t22\t21\t9\t10\t10\t10\t10\n",
    "s5\t20\t22\t10\t10\t13\t10\t10\n",
    "s6\t23\t21\t14\t10\t10\t10\t10\n",
);
const ANCOM_METADATA: &str = concat!(
    "sample\tgroup\n",
    "s4\tplacebo\n",
    "s1\ttreatment\n",
    "s6\tplacebo\n",
    "s2\ttreatment\n",
    "s5\tplacebo\n",
    "s3\ttreatment\n",
);

struct Fixture {
    dir: TempDir,
    table: PathBuf,
    zeros: PathBuf,
    metadata: PathBuf,
}

impl Fixture {
    fn new() -> Self {
        let dir = tempfile::tempdir().unwrap();
        let table = write(dir.path(), "table.tsv", TABLE);
        let zeros = write(dir.path(), "zeros.tsv", ZERO_TABLE);
        let metadata = write(dir.path(), "metadata.tsv", METADATA);
        Self {
            dir,
            table,
            zeros,
            metadata,
        }
    }

    fn path(&self, name: &str) -> PathBuf {
        self.dir.path().join(name)
    }
}

fn write(directory: &Path, name: &str, contents: &str) -> PathBuf {
    let path = directory.join(name);
    fs::write(&path, contents).unwrap();
    path
}

fn run(args: &[&str]) -> Output {
    Command::new(env!("CARGO_BIN_EXE_rsomics-composition"))
        .args(args)
        .output()
        .unwrap()
}

fn run_with_stdin(args: &[&str], input: &str) -> Output {
    let mut child = Command::new(env!("CARGO_BIN_EXE_rsomics-composition"))
        .args(args)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .unwrap();
    child
        .stdin
        .take()
        .unwrap()
        .write_all(input.as_bytes())
        .unwrap();
    child.wait_with_output().unwrap()
}

fn success(output: Output) -> String {
    assert!(
        output.status.success(),
        "status={} stderr={}",
        output.status,
        String::from_utf8_lossy(&output.stderr)
    );
    String::from_utf8(output.stdout).unwrap()
}

#[test]
fn geometry_and_transform_commands_execute_as_real_processes() {
    let fixture = Fixture::new();
    let table = fixture.table.to_str().unwrap();

    for args in [
        vec!["closure", "--input", table],
        vec!["power", "--input", table, "2"],
        vec!["centralize", "--input", table],
        vec!["alr", "--input", table, "--reference", "c"],
        vec!["clr", "--input", table],
        vec!["rclr", "--input", fixture.zeros.to_str().unwrap()],
        vec!["ilr", "--input", table],
    ] {
        let stdout = success(run(&args));
        assert!(
            stdout.starts_with("sample\t"),
            "args={args:?} stdout={stdout}"
        );
    }

    let inner = success(run(&["inner", "--left", table, "--right", table]));
    assert!(inner.starts_with("sample\ts1\ts2\ts3\n"));

    let replacement = success(run(&[
        "multi-replace",
        "--input",
        fixture.zeros.to_str().unwrap(),
    ]));
    assert!(!replacement.contains("\t0\t"));
}

#[test]
fn identity_alignment_basis_and_inverse_paths_are_exercised() {
    let fixture = Fixture::new();
    let operand = write(
        fixture.dir.path(),
        "operand.tsv",
        "sample\tc\ta\tb\ns3\t2\t2\t1\ns1\t1\t3\t2\ns2\t1\t1\t1\n",
    );
    let perturbed = fixture.path("perturbed.tsv");
    success(run(&[
        "perturb",
        "--input",
        fixture.table.to_str().unwrap(),
        "--by",
        operand.to_str().unwrap(),
        "--output",
        perturbed.to_str().unwrap(),
    ]));
    assert!(
        fs::read_to_string(perturbed)
            .unwrap()
            .starts_with("sample\ta\tb\tc\n")
    );

    let basis = fixture.path("basis.tsv");
    success(run(&[
        "basis",
        "--components",
        "a,b,c",
        "--output",
        basis.to_str().unwrap(),
    ]));
    let coordinates = fixture.path("coordinates.tsv");
    success(run(&[
        "ilr",
        "--input",
        fixture.table.to_str().unwrap(),
        "--basis",
        basis.to_str().unwrap(),
        "--output",
        coordinates.to_str().unwrap(),
    ]));
    let reconstructed = fixture.path("reconstructed.tsv");
    success(run(&[
        "ilr",
        "--input",
        coordinates.to_str().unwrap(),
        "--basis",
        basis.to_str().unwrap(),
        "--inverse",
        "--output",
        reconstructed.to_str().unwrap(),
    ]));
    assert!(
        fs::read_to_string(reconstructed)
            .unwrap()
            .starts_with("sample\ta\tb\tc\n")
    );

    let tree = write(fixture.dir.path(), "tree.nwk", "((a,b)ab,c)root;\n");
    let tree_basis = success(run(&[
        "basis",
        "--tree",
        tree.to_str().unwrap(),
        "--components",
        "c,b,a",
    ]));
    assert!(tree_basis.starts_with("sample\tc\tb\ta\nroot\t"));
}

#[test]
fn inference_and_zero_commands_emit_typed_tables() {
    let fixture = Fixture::new();
    let structural = success(run(&[
        "struc-zero",
        "--input",
        fixture.zeros.to_str().unwrap(),
        "--metadata",
        fixture.metadata.to_str().unwrap(),
        "--group",
        "group",
    ]));
    assert!(structural.starts_with("component\tcase\tcontrol\n"));

    let pair = success(run(&[
        "vlr",
        "--input",
        fixture.table.to_str().unwrap(),
        "--left",
        "a",
        "--right",
        "b",
    ]));
    assert!(pair.trim().parse::<f64>().unwrap().is_finite());
    let grid = success(run(&["vlr", "--input", fixture.table.to_str().unwrap()]));
    assert!(grid.starts_with("component\ta\tb\tc\n"));

    let ancom_table = write(fixture.dir.path(), "ancom.tsv", ANCOM_TABLE);
    let metadata = write(fixture.dir.path(), "ancom-metadata.tsv", ANCOM_METADATA);
    let main = fixture.path("ancom-result.tsv");
    let percentiles = fixture.path("percentiles.tsv");
    success(run(&[
        "ancom",
        "--input",
        ancom_table.to_str().unwrap(),
        "--metadata",
        metadata.to_str().unwrap(),
        "--group",
        "group",
        "--output",
        main.to_str().unwrap(),
        "--percentiles-output",
        percentiles.to_str().unwrap(),
    ]));
    let main = fs::read_to_string(main).unwrap();
    assert!(main.starts_with("component\tW\tSignif\n"));
    assert!(main.contains("b2\t4\tTrue\n"));
    assert!(
        fs::read_to_string(percentiles)
            .unwrap()
            .starts_with("component\tpercentile\tgroup\tvalue\n")
    );
}

#[test]
fn stdin_json_and_transaction_boundaries_are_enforced() {
    let fixture = Fixture::new();
    let closure = success(run_with_stdin(&["closure", "--input", "-"], TABLE));
    assert!(closure.starts_with("sample\ta\tb\tc\n"));

    let conflict = run(&[
        "closure",
        "--input",
        fixture.table.to_str().unwrap(),
        "--json",
    ]);
    assert!(!conflict.status.success());
    assert!(String::from_utf8_lossy(&conflict.stderr).contains("named data output"));

    let named = fixture.path("closed.tsv");
    let json = success(run(&[
        "closure",
        "--input",
        fixture.table.to_str().unwrap(),
        "--output",
        named.to_str().unwrap(),
        "--json",
    ]));
    assert!(json.contains("\"status\":\"ok\""), "{json}");
    assert!(
        fs::read_to_string(named)
            .unwrap()
            .starts_with("sample\ta\tb\tc\n")
    );

    let alias = run(&[
        "closure",
        "--input",
        fixture.table.to_str().unwrap(),
        "--output",
        fixture.table.to_str().unwrap(),
    ]);
    assert!(!alias.status.success());
    assert_eq!(fs::read_to_string(&fixture.table).unwrap(), TABLE);

    let invalid = write(
        fixture.dir.path(),
        "invalid-ancom.tsv",
        "sample\ta\tb\ns1\t1\t0\ns2\t2\t3\n",
    );
    let metadata = write(
        fixture.dir.path(),
        "invalid-metadata.tsv",
        "sample\tgroup\ns1\ta\ns2\tb\n",
    );
    let main = fixture.path("must-not-exist.tsv");
    let percentiles = fixture.path("also-must-not-exist.tsv");
    let failed = run(&[
        "ancom",
        "--input",
        invalid.to_str().unwrap(),
        "--metadata",
        metadata.to_str().unwrap(),
        "--group",
        "group",
        "--output",
        main.to_str().unwrap(),
        "--percentiles-output",
        percentiles.to_str().unwrap(),
    ]);
    assert!(!failed.status.success());
    assert!(!main.exists());
    assert!(!percentiles.exists());

    let limited = fixture.path("limited-vlr.tsv");
    let failed = run(&[
        "vlr",
        "--input",
        fixture.table.to_str().unwrap(),
        "--output",
        limited.to_str().unwrap(),
        "--max-dense-cells",
        "8",
    ]);
    assert!(!failed.status.success());
    assert!(!limited.exists());
}