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());
}