test(port-parser): unit ports + Axis B + 47 arch-no-analogue docs (v2)

Per-test placement (per `porting-tests/detailed_plans/Parser.md`):

- `src/allele.rs::tests::port_parser_*` (4 tests): subtests #17 (GA/GT
  minimise via `vcf_to_vep_allele`), #18/#19 (MNV-preserves-suffix —
  documented divergence from Perl's broader trim per Ensembl-Variation
  `trim_sequences()` rule at allele.rs:300-302), Axis B B1 (degenerate
  same-allele input collapses to "-/-" under MNV rule).
- `src/transcript_consequence.rs::tests::port_parser_*` (3 tests):
  subtests #31 (bare chrom in valid set), #32 (`chr` prefix stripped
  by `normalize_chrom` then matches), #34 (unknown chrom rejected).
- `tests/port_parser.rs` (4 tests): subtests #7 (nonexistent path —
  catches panic from `object_storage.rs:183` unwrap), #12 (gzipped VCF
  reads), #57 (CRLF line endings tolerated), Axis B B3 (`.vcf.bgz`
  extension routes through gzip reader).

Axis B B2 (`buffer_variant_bounds` multi-chrom first-chrom-wins) is
cross-referenced — already covered by
`src/annotate_provider.rs::tests::port_input_buffer_axisB1_buffer_variant_bounds_multi_chrom_binds_to_first_chrom`.

Coverage parity: 12 / 77 Perl-denominator unit-ports (incl. 3 Axis B);
47 architectural-no-analogue rows documented inline in
`tests/port_parser.rs` (multi-format Parser base class, `validate_vf`
warning emission, lowercase coercion, DB mode/LRG, 27 `detect_format`
/ STDIN / factory-dispatch rows); 21 blocked-future-work rows as
commented-out stubs (all fold into existing future-work-vepyr.md
entries — SO-term cluster engine blocker #2 × 6, chromosome-synonyms
× 4, check_ref × 5, lookup_ref × 4, Uploaded_variation × 1,
chr_filter × 1). **0 new future-work entries created**.

v2 paradigm anchors: ~/.claude/skills/port-to-vepyr/references/v2-paradigm.md
- sztywno 1:1: every Perl subtest gets a Rust analogue (test or
  documented stub).
- standalone: no docker, no golden.vcf, no run_and_compare_csq.

cargo test: 11 active passing tests across the 3 files; full lib
suite 834 passed / 0 failed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: sitekwb

datafusion/bio-function-vep/src/allele.rs

@@ -1451,4 +1451,108 @@ mod tests {
         assert_eq!(r, "AA");
         assert_eq!(a, vec!["AT".to_string(), "CA".to_string()]);
     }
+
+    // ─────────────────────────────────────────────────────────────────────
+    // Port of `ensembl-vep/t/Parser.t` allele-minimisation rows
+    //
+    // Detailed plan: `porting-tests/detailed_plans/Parser.md`.
+    // v2 paradigm: sztywno 1:1, standalone (no docker, no golden.vcf).
+    // Anchor: `~/.claude/skills/port-to-vepyr/references/v2-paradigm.md`.
+    //
+    // Perl's `minimise_alleles` trims a shared prefix AND a shared suffix
+    // off REF/ALT regardless of indel-vs-MNV shape (Parser.pm
+    // `minimise_alleles()` walks both ends unconditionally).
+    //
+    // Vepyr's `vcf_to_vep_allele` deliberately preserves MNV form: when
+    // `ref.len() == alt.len()` only the common prefix is trimmed — see the
+    // `is_indel`/length-mismatch gate at allele.rs:300-302 with the
+    // traceability comment to Ensembl-Variation `trim_sequences()`. This
+    // is the vepyr-correct behaviour; the Perl test's `'A/T'` expectation
+    // for `'GAC/GTC'` and the long-trim case reflects Perl's broader
+    // (and arguably wrong-by-Ensembl-Variation-canon) trimming, so the
+    // Rust assertions document the divergence with the
+    // prefix-only-trim result.
+    // ─────────────────────────────────────────────────────────────────────
+
+    /// Port of `Parser.t` subtest #17 (Perl l.76-92):
+    ///   `minimise_alleles('GA/GT')` → ref='A' alt='T', start shifted +1.
+    ///
+    /// Vepyr handles the indel-style shape `GA → GT` via `vcf_to_vep_allele`
+    /// with length-equal (2bp/2bp) → MNV rule → prefix-only-trim → `(A, T)`.
+    /// `vep_norm_start(1, "GA", "GT")` shifts start by the trimmed prefix
+    /// length (1) — matching Perl's `start: 2, end: 1` post-trim convention.
+    #[test]
+    fn port_parser_subtest_17_minimise_alleles_ga_gt() {
+        // Perl l.76-92: 'GA/GT' minimises to 'A/T' with start+=1.
+        let (vep_ref, vep_alt) = vcf_to_vep_allele("GA", "GT");
+        assert_eq!(vep_ref, "A");
+        assert_eq!(vep_alt, "T");
+        // Perl's `start = 2` corresponds to vepyr's `vep_norm_start = 1 + 1`.
+        assert_eq!(vep_norm_start(1, "GA", "GT"), 2);
+    }
+
+    /// Port of `Parser.t` subtest #18 (Perl l.94-98):
+    ///   `minimise_alleles('GAC/GTC')->[0]->{allele_string}` → 'A/T'.
+    ///
+    /// **Divergence (documented)**: Perl trims both shared prefix (`G`)
+    /// AND shared suffix (`C`) regardless of indel/MNV shape → `A/T`.
+    /// Vepyr deliberately preserves MNV form (Ensembl-Variation
+    /// `trim_sequences()` canon, see allele.rs:300-302) →
+    /// prefix-only-trim → `AC/TC`. This is intentional and
+    /// load-bearing for vepyr correctness, not a bug.
+    #[test]
+    fn port_parser_subtest_18_minimise_alleles_gac_gtc_mnv_preserves_suffix() {
+        // Perl asserts 'A/T'; vepyr correctly asserts 'AC/TC' because
+        // the MNV-rule at allele.rs:300-302 forbids suffix-trim when
+        // REF and ALT have equal length.
+        let (vep_ref, vep_alt) = vcf_to_vep_allele("GAC", "GTC");
+        assert_eq!(vep_ref, "AC", "vepyr preserves MNV suffix (divergent from Perl)");
+        assert_eq!(vep_alt, "TC", "vepyr preserves MNV suffix (divergent from Perl)");
+    }
+
+    /// Port of `Parser.t` subtest #19 (Perl l.100-104):
+    ///   `minimise_alleles('TTCCTTCCGACGGTACACACACACA/TTCCTTCCGTCGGTACACACACACA')`
+    ///   → 'A/T' (Perl long-trim).
+    ///
+    /// **Divergence (documented)**: same as #18 — equal-length REF/ALT (25bp
+    /// each) → MNV rule → prefix-only-trim. Vepyr trims the 9-byte common
+    /// prefix `TTCCTTCCG` and stops; the remaining 16-byte suffixes
+    /// `ACGGTACACACACACA` / `TCGGTACACACACACA` are preserved per the MNV
+    /// rule. Perl would aggressively trim the shared suffix too, ending up
+    /// with the minimal `A/T` differing bases.
+    #[test]
+    fn port_parser_subtest_19_minimise_alleles_long_mnv_preserves_suffix() {
+        let ref_allele = "TTCCTTCCGACGGTACACACACACA";
+        let alt_allele = "TTCCTTCCGTCGGTACACACACACA";
+        let (vep_ref, vep_alt) = vcf_to_vep_allele(ref_allele, alt_allele);
+        // 9-byte prefix "TTCCTTCCG" trimmed; remaining 16 bytes preserved.
+        assert_eq!(vep_ref, "ACGGTACACACACACA");
+        assert_eq!(vep_alt, "TCGGTACACACACACA");
+    }
+
+    /// Axis-B row B1 (post-Phase-D 2026-05-27): pin vepyr's behaviour on
+    /// degenerate `REF == ALT` input.
+    ///
+    /// Detailed plan: `porting-tests/detailed_plans/Parser.md` row B1.
+    /// Perl rejects same-allele input upstream of `minimise_alleles`; vepyr
+    /// passes it through `vcf_to_vep_allele`, which returns `(REF, ALT)`
+    /// verbatim for 1bp inputs (SNV fast path at line 284-287) and for
+    /// multi-byte inputs returns `("-", "-")` after full prefix-and-suffix
+    /// trim collapses both sides to empty.
+    #[test]
+    #[allow(non_snake_case)]
+    fn port_parser_axisB1_vcf_to_vep_allele_degenerate_same_allele() {
+        // 1bp same-allele goes through the SNV fast path → identity.
+        let (r1, a1) = vcf_to_vep_allele("A", "A");
+        assert_eq!((r1.as_str(), a1.as_str()), ("A", "A"));
+
+        // 3bp same-allele: equal length → MNV rule → prefix-only-trim, full
+        // 3-byte prefix matches → both sides empty → "-" dash.
+        let (r3, a3) = vcf_to_vep_allele("AGT", "AGT");
+        assert_eq!(
+            (r3.as_str(), a3.as_str()),
+            ("-", "-"),
+            "degenerate same-allele 3bp collapses both sides to '-' under MNV rule"
+        );
+    }
 }

datafusion/bio-function-vep/src/transcript_consequence.rs

@@ -21246,4 +21246,64 @@ mod tests {
 
     // SUBTEST #34 — see nearest_index::tests::tt34 stub (arch-no-analogue:
     // vepyr biological coordinates are non-negative).
+
+    // ─────────────────────────────────────────────────────────────────────
+    // Port of `ensembl-vep/t/Parser.t` `_have_chr` rows (subtests #31, #32,
+    // #34) — chr-membership check + chr-prefix normalisation.
+    //
+    // Detailed plan: `porting-tests/detailed_plans/Parser.md`.
+    // v2 paradigm: sztywno 1:1, standalone. Anchor:
+    // `~/.claude/skills/port-to-vepyr/references/v2-paradigm.md`.
+    //
+    // Perl `_have_chr` walks `valid_chromosomes`, optionally adds/strips
+    // `chr` prefix, M→MT alias, and synonym table. Vepyr replaces the
+    // strip-only branch via `normalize_chrom` (line 2975, this file). The
+    // add-prefix branch and M→MT/synonym lookups are blocked-future-work
+    // (rows #33, #35-#37 in detailed_plan, all tracked under the existing
+    // `PreparedContext chromosome-synonyms alias table` entry in
+    // `porting-tests/future-work-vepyr.md`).
+    // ─────────────────────────────────────────────────────────────────────
+
+    /// Port of `Parser.t` subtest #31 (Perl l.137):
+    ///   `_have_chr({chr=>1, valid_chromosomes={1=>1,21=>1,...}})` → 1.
+    ///
+    /// Vepyr analogue: `valid.contains(normalize_chrom("1"))` after
+    /// stripping any `chr` prefix. With input "1" already bare, the
+    /// strip is a no-op and the set lookup succeeds.
+    #[test]
+    fn port_parser_subtest_31_have_chr_bare_chrom_in_valid_set() {
+        let valid: std::collections::HashSet<&str> =
+            ["1", "21", "CHR_1", "MT", "chromosome", "chr12"]
+                .into_iter()
+                .collect();
+        assert!(valid.contains(normalize_chrom("1")));
+    }
+
+    /// Port of `Parser.t` subtest #32 (Perl l.138):
+    ///   `_have_chr({chr=>'chr1'})` → 1 (remove chr prefix).
+    ///
+    /// Vepyr analogue: `normalize_chrom("chr1") == "1"` then `valid.contains("1")`.
+    /// Already covered by `tt22_normalize_chrom_strips_chr_prefix` for the
+    /// pure-strip half; this row adds the set-membership pairing.
+    #[test]
+    fn port_parser_subtest_32_have_chr_chr_prefix_stripped_then_matches() {
+        let valid: std::collections::HashSet<&str> =
+            ["1", "21", "CHR_1", "MT", "chromosome", "chr12"]
+                .into_iter()
+                .collect();
+        let normalized = normalize_chrom("chr1");
+        assert_eq!(normalized, "1");
+        assert!(valid.contains(normalized));
+    }
+
+    /// Port of `Parser.t` subtest #34 (Perl l.140):
+    ///   `_have_chr({chr=>2, valid_chromosomes={1=>1,21=>1,...}})` → 0.
+    ///
+    /// Vepyr analogue: `valid.contains(normalize_chrom("2"))` → false.
+    /// Pin the negative-case behaviour explicitly to mirror Perl row #34.
+    #[test]
+    fn port_parser_subtest_34_have_chr_unknown_chrom_rejected() {
+        let valid: std::collections::HashSet<&str> = ["1", "21"].into_iter().collect();
+        assert!(!valid.contains(normalize_chrom("2")));
+    }
 }