streampile 0.2.0

Forward-only pileups streamed from coordinate-sorted BAM records
Documentation
use std::fs::File;

use noodles::sam::alignment::record::Flags;
use noodles::{bam, bgzf};

use super::{bases, names};
use crate::{AgreementStrategy, AuxValue, DisagreementStrategy, StreamingPileupBuilder};

const READS: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/reads.bam");

type Reader = bam::io::Reader<bgzf::io::Reader<File>>;

fn open<'f>() -> StreamingPileupBuilder<'f, Reader> {
    let mut reader = bam::io::reader::Builder
        .build_from_path(READS)
        .expect("the fixture BAM");
    let header = reader.read_header().expect("the fixture header");
    StreamingPileupBuilder::new(reader, &header).expect("a coordinate-sorted fixture")
}

#[test]
fn test_the_fixture_piles_up_as_the_readme_shows() {
    let mut builder = open().min_base_quality(30);
    let first = builder.pileup("chr1", 10).unwrap();
    assert_eq!(
        (first.filtered_depth(), bases(&first)),
        (4, "ATGA".to_owned())
    );
    let second = builder.pileup("chr1", 12).unwrap();
    assert_eq!(
        (second.filtered_depth(), bases(&second)),
        (3, "GGG".to_owned())
    );
}

#[test]
fn test_the_fixture_pair_is_one_template_whose_mates_agree_and_then_disagree() {
    let paired = |record: &bam::Record| record.flags().is_segmented();
    let mut builder = open().read_filter(paired);
    let mut called = |position, agreement, disagreement| {
        let pileup = builder.pileup("chr1", position).unwrap();
        let templates = pileup.templates(agreement, disagreement);
        assert_eq!(templates.len(), 1);
        let template = &templates[0];
        assert_eq!(template.entries().count(), 2);
        (template.base().map(char::from), template.quality())
    };
    assert_eq!(
        called(
            50,
            AgreementStrategy::Consensus,
            DisagreementStrategy::Consensus
        ),
        (Some('T'), Some(80))
    );
    let disagreeing: Vec<(Option<char>, Option<u8>)> = [
        DisagreementStrategy::Consensus,
        DisagreementStrategy::MaskBoth,
        DisagreementStrategy::MaskLowerQual,
    ]
    .into_iter()
    .map(|strategy| called(52, AgreementStrategy::Consensus, strategy))
    .collect();
    assert_eq!(
        disagreeing,
        [
            (Some('G'), Some(20)),
            (Some('N'), Some(2)),
            (Some('G'), Some(40))
        ]
    );
}

#[test]
fn test_the_fixture_sweeps_a_span() {
    let mut builder = open();
    let mut columns = builder.columns("chr1", 0, 20).unwrap();
    let mut depth = 0;
    while let Some(pileup) = columns.next_pileup() {
        depth += pileup.unwrap().unfiltered_depth();
    }
    assert_eq!(depth, 73);
}

#[test]
fn test_the_fixture_reads_aux_fields_in_place() {
    let mut builder = open()
        .exclude_flags(Flags::empty())
        .index_aux_tags([*b"RG"]);
    let pileup = builder.pileup("chr1", 56).unwrap();
    assert_eq!(names(&pileup), ["pair"]);
    let entry = pileup.get(0).unwrap();
    assert_eq!(entry.aux(*b"RG").unwrap(), Some(AuxValue::String(b"A")));
    assert_eq!(entry.aux(*b"NM").unwrap(), None);
    let mut builder = open();
    let pileup = builder.pileup("chr1", 56).unwrap();
    assert_eq!(
        pileup.get(0).unwrap().aux(*b"RG").unwrap(),
        Some(AuxValue::String(b"A"))
    );
}

#[test]
fn test_the_fixture_pair_measures_both_fragment_ends_from_its_mate_cigars() {
    let mut builder = open();
    let pileup = builder.pileup("chr1", 45).unwrap();
    let distances: Vec<(u16, Option<usize>, Option<usize>)> = pileup
        .iter()
        .map(|entry| {
            (
                entry.flags().bits(),
                entry.five_prime_distance(),
                entry.template_end_distance().unwrap(),
            )
        })
        .collect();
    assert_eq!(
        distances,
        [
            (0, Some(5), None),
            (99, Some(5), Some(14)),
            (147, Some(14), Some(5))
        ]
    );
}