test: build option structs by parsing, not by struct literal

`MultiplexQuantOpts` and ATAC `ProcessOpts` were constructed in tests with
struct literals naming every field. A literal must name all of them, so each
new CLI option is an E0063 in that file -- and `cargo build` does not compile
tests, so it only surfaces under `cargo test` / `--all-targets`, typically
after the change looks like it compiles.

The same literal has now broken three times: 53c7f31 (--sample-bc-ori, arriving
broken in PR #199), b3192a3 (the flattened decoder options), and --small-thresh
today. Meanwhile the equivalent tests for MapQuantOpts never broke, because
quant.rs builds its opts with `Cli::parse_from`. Adopt that pattern in both
places: new options pick up their clap defaults, and an option that is
genuinely required fails loudly at parse time naming itself.

`atac process` requires a read-input form at parse time, so the helper supplies
one and then clears it, keeping the exact baseline the assertions were written
against. The AtacChemistry/Macs3GenomeSize imports existed only to name types
in the literal and are now unused.

Four small literals remain in chemistry.rs, where each test exercises specific
field combinations and the structs are stable; those are left alone.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VhyNvEWUgY8ALVacdJHxVJ

Author: rob-p

src/atac/process.rs

@@ -621,46 +621,45 @@ fn af_gpl(af_home_path: &Path, opts: &ProcessOpts) -> anyhow::Result<GplStageOut
 mod tests {
     use std::fs;
 
-    use crate::atac::commands::{AtacChemistry, Macs3GenomeSize};
-
     use super::*;
 
+    /// Build `ProcessOpts` the way a user would: by parsing a command line.
+    /// A struct literal has to name every field, so adding an option to the
+    /// CLI breaks this file with an E0063 that only `--all-targets` surfaces
+    /// -- `cargo build` does not compile tests. Parsing instead lets new
+    /// options pick up their clap defaults, and anything genuinely required
+    /// fails loudly at parse time.
     fn base_process_opts() -> ProcessOpts {
-        ProcessOpts {
-            decode: crate::simpleaf_commands::PiscemDecoderOpts {
-                decoder: String::from("auto"),
-                thread_policy: None,
-            },
-            index: PathBuf::from("/tmp/index"),
-            reads1: None,
-            reads2: None,
-            reads: None,
-            barcode_reads: vec![],
-            chemistry: AtacChemistry::TenxV2,
-            barcode_length: 16,
-            output: PathBuf::from("/tmp/out"),
-            threads: 1,
-            call_peaks: false,
-            permit_barcode_ori: None,
-            unfiltered_pl: None,
-            min_reads: 10,
-            compress: false,
-            ignore_ambig_hits: false,
-            no_poison: false,
-            use_chr: false,
-            thr: 0.8,
-            bin_size: 50,
-            bin_overlap: 2,
-            no_tn5_shift: false,
-            check_kmer_orphan: false,
-            max_ec_card: 4096,
-            max_hit_occ: 64,
-            max_hit_occ_recover: 1024,
-            max_read_occ: 250,
-            gsize: Macs3GenomeSize::KnownOpt("hs"),
-            qvalue: 0.1,
-            extsize: 50,
-        }
+        use clap::Parser;
+        let cli_args = vec![
+            "simpleaf",
+            "atac",
+            "process",
+            "--index",
+            "/tmp/index",
+            "--output",
+            "/tmp/out",
+            "--chemistry",
+            "10x-v2",
+            "--barcode-reads",
+            "/tmp/bc.fastq",
+            "--threads",
+            "1",
+            // one of the read-input forms is required at parse time; the
+            // tests below supply their own, so clear it back out afterwards
+            // to keep the baseline these assertions were written against.
+            "--reads",
+            "/tmp/r.fastq",
+        ];
+        let mut opts = match crate::Cli::parse_from(cli_args).command {
+            crate::simpleaf_commands::Commands::Atac(
+                crate::atac::commands::AtacCommand::Process(opts),
+            ) => opts,
+            cmd => panic!("expected atac process command, found {:?}", cmd),
+        };
+        opts.reads = None;
+        opts.barcode_reads = vec![];
+        opts
     }
 
     #[test]

src/simpleaf_commands/multiplex_quant.rs

@@ -783,6 +783,7 @@ mod tests {
     use super::{resolve_user_supplied_index, t2g_mode};
     use crate::simpleaf_commands::MultiplexQuantOpts;
     use crate::utils::probe_utils::ProbeT2gMode;
+    use clap::Parser;
     use serde_json::json;
     use std::fs;
     use std::path::Path;
@@ -857,40 +858,24 @@ mod tests {
         assert!(gene_id_to_name.is_none());
     }
 
+    /// Build `MultiplexQuantOpts` the way a user would: by parsing a command
+    /// line. A struct literal has to name every field, so adding an option to
+    /// the CLI breaks this file with an E0063 that only `--all-targets`
+    /// surfaces -- `cargo build` does not compile tests. Parsing instead lets
+    /// new options pick up their clap defaults, and anything genuinely
+    /// required fails loudly at parse time.
+    fn parse_multiplex_quant_opts(args: &[&str]) -> MultiplexQuantOpts {
+        let mut cli_args = vec!["simpleaf", "multiplex-quant"];
+        cli_args.extend_from_slice(args);
+        match crate::Cli::parse_from(cli_args).command {
+            crate::simpleaf_commands::Commands::MultiplexQuant(opts) => opts,
+            cmd => panic!("expected multiplex-quant command, found {:?}", cmd),
+        }
+    }
+
     #[test]
     fn usa_flag_maps_to_usa_mode() {
-        let opts = MultiplexQuantOpts {
-            chemistry: None,
-            geometry: None,
-            organism: None,
-            cell_bc_list: None,
-            expected_ori: String::from("both"),
-            sample_bc_ori: None,
-            decode: crate::simpleaf_commands::PiscemDecoderOpts {
-                decoder: String::from("auto"),
-                thread_policy: None,
-            },
-            sample_correction_mode: String::from("exact"),
-            output: Path::new(".").to_path_buf(),
-            threads: 1,
-            index: None,
-            probe_set: None,
-            t2g_map: None,
-            usa: true,
-            sample_bc_list: None,
-            reads1: Vec::new(),
-            reads2: Vec::new(),
-            resolution: String::from("cr-like"),
-            small_thresh: None,
-            kmer_length: 23,
-            skipping_strategy: String::from("permissive"),
-            struct_constraints: false,
-            max_ec_card: 4096,
-            dict: crate::simpleaf_commands::PiscemDict::Auto,
-            min_reads: 10,
-            anndata_out: false,
-        };
-
+        let opts = parse_multiplex_quant_opts(&["-o", ".", "--usa"]);
         assert_eq!(t2g_mode(&opts), ProbeT2gMode::Usa);
     }