test: regression test infra and snapshots

CONTRIBUTING.md

@@ -13,6 +13,32 @@ cargo fmt
 cargo clippy --workspace
 ```
 
+## Regression tests
+
+End-to-end regression tests live in `tests/regression/` and compare subcommand
+output against committed snapshots using [insta](https://insta.rs/). Each test
+runs the `ft` binary against a fixture in `tests/data/`, projects a stable
+subset of columns (so trailing/added columns aren't false positives), and
+asserts the result matches the snapshot in `tests/regression/snapshots/`.
+
+Run just the regression suite with:
+
+```bash
+cargo test --test regression
+```
+
+When you intentionally change output, regenerate snapshots with
+[`cargo-insta`](https://insta.rs/docs/cli/):
+
+```bash
+cargo install cargo-insta      # one-time
+cargo insta test --review      # walk through diffs interactively
+# or, if the new output is correct as-is:
+cargo insta accept
+```
+
+Inspect the resulting `.snap` diff before committing.
+
 ## Cutting a release
 
 The changelog is managed by git-cliff which will run with the release action.

Cargo.toml

@@ -83,7 +83,9 @@ vergen-git2 = { version = "1.0.2", features = [
 
 [dev-dependencies]
 assert_cmd = "2.0.11"
+insta = "1.47.2"
 predicates = "3.0.3"
+tempfile = "3.3.0"
 
 [features]
 cli = ["dep:clap", "dep:clap_complete", "dep:clap_mangen", "dep:console"]

tests/data/center.small.bed

@@ -0,0 +1,3 @@
+chr1	41417257	41417292	CTCF_XL	3.160000e-11	-	CAGCAGTTTCTGCCGCATGCCACCAGAGGGCACCA
+chr11	44286466	44286501	CTCF_XL	9.450000e-11	+	CTGCAGTTGTGCATGCTGGCCACCAGGAGGCACTG
+chr15	74054174	74054209	CTCF_XL	3.870000e-11	+	AAGCAGTTCCCCCATGTAACCTGCAGGTGGCACCA

tests/regression.rs

@@ -0,0 +1,12 @@
+#[path = "regression/center.rs"]
+mod center;
+#[path = "regression/common.rs"]
+mod common;
+#[path = "regression/extract.rs"]
+mod extract;
+#[path = "regression/fire.rs"]
+mod fire;
+#[path = "regression/pileup.rs"]
+mod pileup;
+#[path = "regression/qc.rs"]
+mod qc;

tests/regression/center.rs

@@ -0,0 +1,28 @@
+use super::common::{fixture, run, select_tsv_cols};
+
+// Subset to 3 motifs and cap features to ±200 bp of center to keep the
+// snapshot small. The center math is uniform across distance, so this
+// still exercises liftover + strand flipping for m6a/nuc/msp types.
+#[test]
+fn center_default() {
+    let out = run(&[
+        "center",
+        fixture("center.bam").to_str().unwrap(),
+        "--bed",
+        fixture("center.small.bed").to_str().unwrap(),
+        "--dist",
+        "200",
+    ]);
+    insta::assert_snapshot!(select_tsv_cols(
+        &out,
+        &[
+            "chrom",
+            "centering_position",
+            "strand",
+            "query_name",
+            "centered_position_type",
+            "centered_start",
+            "centered_end",
+        ]
+    ));
+}

tests/regression/common.rs

@@ -0,0 +1,96 @@
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+pub fn ft() -> PathBuf {
+    env!("CARGO_BIN_EXE_ft").into()
+}
+
+pub fn fixture(name: &str) -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("tests/data")
+        .join(name)
+}
+
+/// Select named columns from TSV output by header name, in the order given.
+/// Snapshots only the specified columns so that adding new columns to a
+/// command's output doesn't count as a regression.
+pub fn select_tsv_cols(tsv: &str, cols: &[&str]) -> String {
+    let mut lines = tsv.lines();
+    let headers: Vec<&str> = lines.next().unwrap_or("").split('\t').collect();
+    let indices: Vec<usize> = cols
+        .iter()
+        .map(|c| {
+            headers
+                .iter()
+                .position(|h| h == c)
+                .unwrap_or_else(|| panic!("column {c:?} not found; headers: {headers:?}"))
+        })
+        .collect();
+    let mut out = cols.join("\t") + "\n";
+    for line in lines {
+        let fields: Vec<&str> = line.split('\t').collect();
+        out += &indices
+            .iter()
+            .map(|&i| fields.get(i).copied().unwrap_or(""))
+            .collect::<Vec<_>>()
+            .join("\t");
+        out += "\n";
+    }
+    out
+}
+
+/// Select bed12 fields by name from headerless bed12 output. Field names follow
+/// the bed12 spec. Emits a synthetic header so snapshots stay self-describing,
+/// and lets tests drop redundant/constant columns (score, thick_*, item_rgb)
+/// without binding to numeric indices.
+pub fn select_bed12_cols(tsv: &str, cols: &[&str]) -> String {
+    const BED12: &[&str] = &[
+        "chrom",
+        "start",
+        "end",
+        "name",
+        "score",
+        "strand",
+        "thick_start",
+        "thick_end",
+        "item_rgb",
+        "block_count",
+        "block_sizes",
+        "block_starts",
+    ];
+    let indices: Vec<usize> = cols
+        .iter()
+        .map(|c| {
+            BED12
+                .iter()
+                .position(|f| f == c)
+                .unwrap_or_else(|| panic!("bed12 field {c:?} not in spec; valid: {BED12:?}"))
+        })
+        .collect();
+    let mut out = cols.join("\t") + "\n";
+    for line in tsv.lines() {
+        let fields: Vec<&str> = line.split('\t').collect();
+        out += &indices
+            .iter()
+            .map(|&i| fields.get(i).copied().unwrap_or(""))
+            .collect::<Vec<_>>()
+            .join("\t");
+        out += "\n";
+    }
+    out
+}
+
+/// Run ft with the given args; return stdout as a String. Panics on non-zero exit.
+pub fn run(args: &[&str]) -> String {
+    let out = Command::new(ft())
+        .args(args)
+        .output()
+        .expect("failed to spawn ft");
+    assert!(
+        out.status.success(),
+        "ft exited {}\nstderr: {}",
+        out.status,
+        String::from_utf8_lossy(&out.stderr)
+    );
+    String::from_utf8(out.stdout).expect("non-UTF8 stdout")
+}