use std::fs::File;
use std::io::{self, Write};
use std::path::{Path, PathBuf};
use super::*;
use crate::{Allele, MultiallelicCaller, Ploidy, SampleEvidence, SampleLikelihood};
const FORMATS: [VariantOutputFormat; 4] = [
VariantOutputFormat::Vcf,
VariantOutputFormat::VcfBgzf,
VariantOutputFormat::BcfRaw,
VariantOutputFormat::BcfBgzf,
];
#[test]
fn roundtrips_likelihood_streams_in_all_formats() {
let (schema, site) = fixture();
for format in FORMATS {
let mut writer = LikelihoodVariantWriter::new(Vec::new(), schema.clone(), format).unwrap();
writer.write_site(&site).unwrap();
let data = writer.finish().unwrap();
let mut reader = LikelihoodVariantReader::new(&data[..]).unwrap();
assert_eq!(
reader.schema().header().file_format(),
schema.header().file_format()
);
assert_eq!(
reader
.schema()
.header()
.contigs()
.keys()
.collect::<Vec<_>>(),
schema.header().contigs().keys().collect::<Vec<_>>()
);
assert_eq!(
reader
.schema()
.header()
.sample_names()
.iter()
.collect::<Vec<_>>(),
schema.header().sample_names().iter().collect::<Vec<_>>()
);
assert_eq!(reader.read_site().unwrap(), Some(site.clone()));
assert_eq!(reader.read_site().unwrap(), None);
}
}
#[test]
fn writes_called_streams_in_all_formats() {
let (likelihood_schema, site) = fixture();
let called = MultiallelicCaller::default().call(&site).unwrap();
for format in FORMATS {
let schema = CalledVcfSchema::from_likelihood(&likelihood_schema);
let mut writer = CalledVariantWriter::new(Vec::new(), schema, format).unwrap();
writer.write_site(&called).unwrap();
let data = writer.finish().unwrap();
let mut reader = variant::io::Reader::new(&data[..]).unwrap();
let header = reader.read_header().unwrap();
let mut record = variant::Record::default();
assert_ne!(reader.read_record(&mut record).unwrap(), 0);
let record = vcf::variant::RecordBuf::try_from_variant_record(&header, &record).unwrap();
assert_eq!(record.reference_sequence_name(), "chr1");
assert!(record.info().get("AN").is_some());
assert_eq!(
reader.read_record(&mut variant::Record::default()).unwrap(),
0
);
}
}
#[test]
fn rejects_truncated_compressed_input() {
let (schema, site) = fixture();
let mut writer =
LikelihoodVariantWriter::new(Vec::new(), schema, VariantOutputFormat::BcfBgzf).unwrap();
writer.write_site(&site).unwrap();
let mut data = writer.finish().unwrap();
data.truncate(data.len() / 2);
let result = LikelihoodVariantReader::new(&data[..]).and_then(|mut reader| reader.read_site());
assert!(matches!(
result,
Err(CallError::LikelihoodVariantInput(_) | CallError::LikelihoodVariantRecord { .. })
));
}
#[test]
fn reports_the_invalid_record_number() {
let src = b"##fileformat=VCFv4.2\n\
##contig=<ID=chr1,length=100>\n\
##INFO=<ID=QS,Number=R,Type=Float,Description=\"Auxiliary tag used for calling\">\n\
##FORMAT=<ID=PL,Number=G,Type=Integer,Description=\"Likelihoods\">\n\
#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tsample\n\
chr1\t1\t.\tA\tG\t.\t.\tQS=1,1\tPL\t40,3,0\n\
chr1\t2\t.\tA\tG\t.\t.\t.\tPL\t40,3,0\n";
let mut reader = LikelihoodVariantReader::new(&src[..]).unwrap();
reader.read_site().unwrap();
assert!(matches!(
reader.read_site(),
Err(CallError::LikelihoodVariantRecord { record: 2, .. })
));
}
#[test]
fn reports_deferred_output_failures() {
let (schema, site) = fixture();
let mut writer =
LikelihoodVariantWriter::new(RejectWrites, schema, VariantOutputFormat::VcfBgzf).unwrap();
writer.write_site(&site).unwrap();
assert!(matches!(writer.finish(), Err(CallError::VariantOutput(_))));
}
#[test]
fn projects_likelihood_samples_during_decode() {
let (schema, site) = multi_sample_fixture();
for format in FORMATS {
let mut writer = LikelihoodVariantWriter::new(Vec::new(), schema.clone(), format).unwrap();
writer.write_site(&site).unwrap();
let data = writer.finish().unwrap();
let mut reader = LikelihoodVariantReader::new(&data[..])
.unwrap()
.select_samples(["third", "first"])
.unwrap();
assert_eq!(
reader
.schema()
.header()
.sample_names()
.iter()
.map(String::as_str)
.collect::<Vec<_>>(),
["third", "first"]
);
let projected = reader.read_site().unwrap().unwrap();
assert_eq!(projected.samples().len(), 2);
assert_eq!(
projected.samples()[0].phred_likelihoods(),
site.samples()[2].phred_likelihoods()
);
assert_eq!(
projected.samples()[1].phred_likelihoods(),
site.samples()[0].phred_likelihoods()
);
let mut reader = LikelihoodVariantReader::new(&data[..])
.unwrap()
.exclude_samples(["second"])
.unwrap();
assert_eq!(
reader
.schema()
.header()
.sample_names()
.iter()
.map(String::as_str)
.collect::<Vec<_>>(),
["first", "third"]
);
assert_eq!(reader.read_site().unwrap().unwrap().samples().len(), 2);
}
}
#[test]
fn reads_and_projects_prior_frequency_tags() {
let src = b"##fileformat=VCFv4.2\n\
##contig=<ID=chr1,length=100>\n\
##INFO=<ID=QS,Number=R,Type=Float,Description=\"Auxiliary tag used for calling\">\n\
##INFO=<ID=PAN,Number=1,Type=Integer,Description=\"Panel allele number\">\n\
##INFO=<ID=PAC,Number=A,Type=Integer,Description=\"Panel alternate counts\">\n\
##FORMAT=<ID=PL,Number=G,Type=Integer,Description=\"Likelihoods\">\n\
#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tsample\n\
chr1\t1\t.\tA\tG,<*>\t.\t.\tQS=1,1,0;PAN=10;PAC=2,0\tPL\t40,3,0,40,3,40\n";
let mut reader = LikelihoodVariantReader::new(&src[..])
.unwrap()
.with_prior_frequencies("PAN", "PAC")
.unwrap();
let site = reader.read_site().unwrap().unwrap();
assert_eq!(site.prior_allele_counts().unwrap().total(), 10);
assert_eq!(site.prior_allele_counts().unwrap().alternates(), &[2, 0]);
let called = MultiallelicCaller::default().call(&site).unwrap();
let schema = CalledVcfSchema::from_likelihood(reader.schema());
let mut writer =
CalledVariantWriter::new(Vec::new(), schema, VariantOutputFormat::Vcf).unwrap();
writer.write_site(&called).unwrap();
let output = String::from_utf8(writer.finish().unwrap()).unwrap();
let record = output.lines().find(|line| !line.starts_with('#')).unwrap();
assert!(record.split('\t').nth(7).unwrap().contains("PAN=10;PAC=2"));
let standard = String::from_utf8(src.to_vec())
.unwrap()
.replace("PAN", "AN")
.replace("PAC", "AC");
let mut reader = LikelihoodVariantReader::new(standard.as_bytes())
.unwrap()
.with_prior_frequencies("AN", "AC")
.unwrap();
let called = MultiallelicCaller::default()
.call(&reader.read_site().unwrap().unwrap())
.unwrap();
let schema = CalledVcfSchema::from_likelihood(reader.schema());
let mut writer =
CalledVariantWriter::new(Vec::new(), schema, VariantOutputFormat::Vcf).unwrap();
writer.write_site(&called).unwrap();
let output = String::from_utf8(writer.finish().unwrap()).unwrap();
let info = output
.lines()
.find(|line| !line.starts_with('#'))
.unwrap()
.split('\t')
.nth(7)
.unwrap();
assert!(info.contains("AC=2;AN=2"));
assert!(matches!(
LikelihoodVariantReader::new(&src[..])
.unwrap()
.with_prior_frequencies("missing", "PAC"),
Err(CallError::InvalidLikelihoodVariant(_))
));
}
#[test]
fn rejects_invalid_or_late_likelihood_sample_selection() {
let (schema, site) = multi_sample_fixture();
let mut writer =
LikelihoodVariantWriter::new(Vec::new(), schema, VariantOutputFormat::Vcf).unwrap();
writer.write_site(&site).unwrap();
let data = writer.finish().unwrap();
assert!(matches!(
LikelihoodVariantReader::new(&data[..])
.unwrap()
.select_samples(["first", "first"]),
Err(CallError::DuplicateSampleSelection(_))
));
assert!(matches!(
LikelihoodVariantReader::new(&data[..])
.unwrap()
.exclude_samples(["absent"]),
Err(CallError::MissingSelectedSample(_))
));
assert!(matches!(
LikelihoodVariantReader::new(&data[..])
.unwrap()
.exclude_samples(["first", "second", "third"]),
Err(CallError::InvalidSampleCount)
));
let mut reader = LikelihoodVariantReader::new(&data[..]).unwrap();
reader.read_site().unwrap();
assert!(matches!(
reader.select_samples(["first"]),
Err(CallError::LateLikelihoodReaderConfiguration)
));
}
#[test]
fn indexed_regions_follow_header_order_and_deduplicate_spanning_records() {
let directory = tempfile::tempdir().unwrap();
let schema = LikelihoodVcfSchema::new(
[(b"chr2".as_slice(), 100), (b"chr1".as_slice(), 100)],
["sample"],
)
.unwrap();
let input = write_indexed_likelihoods(
directory.path(),
schema,
[site(0, 9, b"AAAAAA"), site(1, 1, b"A"), site(1, 3, b"A")],
);
let reader = IndexedLikelihoodVariantReader::open(input).unwrap();
let mut sites = Vec::new();
let regions = reader
.normalize_regions(
["chr1:4-4", "chr2:13-13", "chr2:10-10"].map(|region| region.parse().unwrap()),
)
.unwrap();
reader
.visit_normalized_regions(regions, |_, site| {
sites.push(site);
Ok(())
})
.unwrap();
assert_eq!(
sites
.iter()
.map(|site| (site.reference_sequence_id(), site.position()))
.collect::<Vec<_>>(),
[(0, 9), (1, 3)]
);
}
#[test]
fn indexed_regions_validate_selection_and_project_samples() {
let directory = tempfile::tempdir().unwrap();
let (schema, site) = multi_sample_fixture();
let input = write_indexed_likelihoods(directory.path(), schema, [site]);
let reader = IndexedLikelihoodVariantReader::open(&input)
.unwrap()
.select_samples(["third", "first"])
.unwrap();
assert_eq!(
reader
.schema()
.header()
.sample_names()
.iter()
.map(String::as_str)
.collect::<Vec<_>>(),
["third", "first"]
);
assert!(matches!(
IndexedLikelihoodVariantReader::open(&input)
.unwrap()
.normalize_regions(std::iter::empty()),
Err(CallError::MissingRegions)
));
assert!(matches!(
IndexedLikelihoodVariantReader::open(input)
.unwrap()
.normalize_regions(["missing:1-2".parse().unwrap()]),
Err(CallError::InvalidRegion { .. })
));
}
fn fixture() -> (LikelihoodVcfSchema, LikelihoodSite) {
let schema = LikelihoodVcfSchema::new([(b"chr1".as_slice(), 100)], ["sample"]).unwrap();
let site = LikelihoodSite::new(
0,
9,
Allele::new(&b"A"[..]).unwrap(),
[Allele::new(&b"G"[..]).unwrap()],
[1.0, 1.0],
[SampleLikelihood::observed(
Ploidy::new(2).unwrap(),
[40, 3, 0],
SampleEvidence::new(1, [0, 1], [0, 40]).unwrap(),
)
.unwrap()],
)
.unwrap();
(schema, site)
}
fn multi_sample_fixture() -> (LikelihoodVcfSchema, LikelihoodSite) {
let schema =
LikelihoodVcfSchema::new([(b"chr1".as_slice(), 100)], ["first", "second", "third"])
.unwrap();
let samples = [[0, 3, 40], [40, 3, 0], [20, 0, 20]].map(|likelihoods| {
SampleLikelihood::observed(
Ploidy::new(2).unwrap(),
likelihoods,
SampleEvidence::new(1, [1, 0], [40, 0]).unwrap(),
)
.unwrap()
});
let site = LikelihoodSite::new(
0,
9,
Allele::new(&b"A"[..]).unwrap(),
[Allele::new(&b"G"[..]).unwrap()],
[1.0, 1.0],
samples,
)
.unwrap();
(schema, site)
}
fn site(reference_sequence_id: usize, position: u64, reference: &[u8]) -> LikelihoodSite {
LikelihoodSite::new(
reference_sequence_id,
position,
Allele::new(reference).unwrap(),
[Allele::new(&b"G"[..]).unwrap()],
[1.0, 1.0],
[SampleLikelihood::observed(
Ploidy::new(2).unwrap(),
[40, 3, 0],
SampleEvidence::new(1, [0, 1], [0, 40]).unwrap(),
)
.unwrap()],
)
.unwrap()
}
fn write_indexed_likelihoods(
directory: &Path,
schema: LikelihoodVcfSchema,
sites: impl IntoIterator<Item = LikelihoodSite>,
) -> PathBuf {
let path = directory.join("likelihoods.vcf.gz");
let mut writer = LikelihoodVariantWriter::new(
File::create(&path).unwrap(),
schema,
VariantOutputFormat::VcfBgzf,
)
.unwrap();
for site in sites {
writer.write_site(&site).unwrap();
}
writer.finish().unwrap();
let index = vcf::fs::index(&path).unwrap();
noodles::tabix::fs::write(format!("{}.tbi", path.display()), &index).unwrap();
path
}
struct RejectWrites;
impl Write for RejectWrites {
fn write(&mut self, _: &[u8]) -> io::Result<usize> {
Err(io::Error::other("rejected write"))
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}