def test_adaptor_with_ownership(self, take_ownership):
mock_writer = mock.MagicMock()
adaptor = io.RawProtoWriterAdaptor(mock_writer,
take_ownership=take_ownership)
# Write out protos to our adaptor.
with adaptor as enter_return_value:
# Make sure that __enter__ returns the adaptor itself.
self.assertIs(adaptor, enter_return_value)
adaptor.write(self.proto1)
adaptor.write(self.proto2)
if take_ownership:
# If we took ownership, mock_writer __enter__ and __exit__ should have
# been called.
mock_writer.__enter__.assert_called_once_with()
test_utils.assert_called_once_workaround(mock_writer.__exit__)
else:
# If not, they shouldn't have been called.
test_utils.assert_not_called_workaround(mock_writer.__enter__)
test_utils.assert_not_called_workaround(mock_writer.__exit__)
self.assertEqual(
mock_writer.write.call_args_list,
[mock.call(r.SerializeToString()) for r in self.protos])
def test_process_with_realigner(self):
self.processor.options.mode = deepvariant_pb2.DeepVariantOptions.CALLING
self.processor.options.realigner_options.CopyFrom(
realigner_pb2.RealignerOptions())
self.processor.realigner = mock.Mock()
self.processor.realigner.realign_reads.return_value = [], []
self.processor.sam_reader = mock.Mock()
self.processor.sam_reader.query.return_value = []
self.processor.in_memory_sam_reader = mock.Mock()
c1, c2 = mock.Mock(), mock.Mock()
e1, e2, e3 = mock.Mock(), mock.Mock(), mock.Mock()
self.add_mock('candidates_in_region', retval=([c1, c2], []))
mock_cpe = self.add_mock(
'create_pileup_examples', side_effect=[[e1], [e2, e3]])
mock_lc = self.add_mock('label_candidates')
self.assertEqual(([c1, c2], [e1, e2, e3], []),
self.processor.process(self.region))
self.processor.sam_reader.query.assert_called_once_with(self.region)
self.processor.realigner.realign_reads.assert_called_once_with([],
self.region)
self.processor.in_memory_sam_reader.replace_reads.assert_called_once_with(
[])
self.assertEqual([mock.call(c1), mock.call(c2)], mock_cpe.call_args_list)
test_utils.assert_not_called_workaround(mock_lc)
def test_process_calls_with_candidates(self, mode):
self.processor.options.mode = mode
self.processor.in_memory_sam_reader = mock.Mock()
mock_read = mock.MagicMock()
mock_candidate = mock.MagicMock()
mock_example = mock.MagicMock()
mock_label = mock.MagicMock()
mock_rr = self.add_mock('region_reads', retval=[mock_read])
mock_cir = self.add_mock(
'candidates_in_region', retval=([mock_candidate], []))
mock_cpe = self.add_mock('create_pileup_examples', retval=[mock_example])
mock_lc = self.add_mock(
'label_candidates', retval=[(mock_candidate, mock_label)])
mock_alte = self.add_mock('add_label_to_example', retval=mock_example)
self.assertEqual(([mock_candidate], [mock_example], []),
self.processor.process(self.region))
mock_rr.assert_called_once_with(self.region)
self.processor.in_memory_sam_reader.replace_reads.assert_called_once_with(
[mock_read])
mock_cir.assert_called_once_with(self.region)
mock_cpe.assert_called_once_with(mock_candidate)
if mode == deepvariant_pb2.DeepVariantOptions.TRAINING:
mock_lc.assert_called_once_with([mock_candidate])
mock_alte.assert_called_once_with(mock_example, mock_label)
else:
# In training mode we don't label our candidates.
test_utils.assert_not_called_workaround(mock_lc)
test_utils.assert_not_called_workaround(mock_alte)
def test_process_keeps_ordering_of_candidates_and_examples(self, mode):
self.processor.options.mode = mode
r1, r2 = mock.Mock(), mock.Mock()
c1, c2 = mock.Mock(), mock.Mock()
l1, l2 = mock.Mock(), mock.Mock()
e1, e2, e3 = mock.Mock(), mock.Mock(), mock.Mock()
self.processor.in_memory_sam_reader = mock.Mock()
self.add_mock('region_reads', retval=[r1, r2])
self.add_mock('candidates_in_region', retval=([c1, c2], []))
mock_cpe = self.add_mock(
'create_pileup_examples', side_effect=[[e1], [e2, e3]])
mock_lc = self.add_mock('label_candidates', retval=[(c1, l1), (c2, l2)])
mock_alte = self.add_mock('add_label_to_example', side_effect=[e1, e2, e3])
self.assertEqual(([c1, c2], [e1, e2, e3], []),
self.processor.process(self.region))
self.processor.in_memory_sam_reader.replace_reads.assert_called_once_with(
[r1, r2])
# We don't try to label variants when in calling mode.
self.assertEqual([mock.call(c1), mock.call(c2)], mock_cpe.call_args_list)
if mode == deepvariant_pb2.DeepVariantOptions.CALLING:
# In calling mode, we never try to label.
test_utils.assert_not_called_workaround(mock_lc)
test_utils.assert_not_called_workaround(mock_alte)
else:
mock_lc.assert_called_once_with([c1, c2])
self.assertEqual([
mock.call(e1, l1),
mock.call(e2, l2),
mock.call(e3, l2),
], mock_alte.call_args_list)
def test_process_calls_no_candidates(self):
main_sample = self.processor.samples[0]
mock_rr = self.add_mock('region_reads', retval=[])
mock_cir = self.add_mock('candidates_in_region',
retval=({
'main_sample': []
}, {
'main_sample': []
}))
mock_cpe = self.add_mock('create_pileup_examples', retval=[])
mock_lc = self.add_mock('label_candidates')
candidates, examples, gvcfs, runtimes = self.processor.process(
self.region)
self.assertEmpty(candidates['main_sample'])
self.assertEmpty(examples['main_sample'])
self.assertEmpty(gvcfs['main_sample'])
self.assertIsInstance(runtimes, dict)
mock_rr.assert_called_once_with(
region=self.region,
sam_readers=None,
reads_filenames=main_sample.options.reads_filenames)
main_sample.in_memory_sam_reader.replace_reads.assert_called_once_with(
[])
mock_cir.assert_called_once_with(self.region)
test_utils.assert_not_called_workaround(mock_cpe)
mock_lc.assert_called_once_with([], self.region)
def test_image_no_reads(self):
# This image is created just from reference and no reads. Checks that the
# function is listening to all of our image creation parameters (e.g.,
# reference_band_height, width, height, etc) and is filling the image with
# empty rows when it runs out of reads.
image = self.pic.build_pileup(self.dv_call, self.ref, [], {self.alt_allele})
self.mock_enc_ref.assert_called_once_with(self.ref)
test_utils.assert_not_called_workaround(self.mock_enc_read)
self.assertImageMatches(image, 'ref', 'ref', 'empty', 'empty')
def test_image_no_reads(self):
# This image is created just from reference and no reads. Checks that the
# function is listening to all of our image creation parameters (e.g.,
# reference_band_height, width, height, etc) and is filling the image with
# empty rows when it runs out of reads.
image = self.pic.build_pileup(self.dv_call, self.ref, [], {self.alt_allele})
self.mock_enc_ref.assert_called_once_with(self.ref)
test_utils.assert_not_called_workaround(self.mock_enc_read)
self.assertImageMatches(image, 'ref', 'ref', 'empty', 'empty')
def test_model_init_function(self, path, expected):
model = mock.Mock(spec=modeling.DeepVariantModel)
model.initialize_from_checkpoint.return_value = MOCK_SENTINEL_RETURN_VALUE
self.assertEqual(expected, model_train.model_init_function(model, 3, path))
if expected:
model.initialize_from_checkpoint.assert_called_once_with(
path, 3, is_training=True)
else:
test_utils.assert_not_called_workaround(model.initialize_from_checkpoint)
def test_model_init_function(self, path, expected):
model = mock.Mock(spec=modeling.DeepVariantModel)
model.initialize_from_checkpoint.return_value = MOCK_SENTINEL_RETURN_VALUE
self.assertEqual(expected,
model_train.model_init_function(model, 3, path))
if expected:
model.initialize_from_checkpoint.assert_called_once_with(
path, 3, is_training=True)
else:
test_utils.assert_not_called_workaround(
model.initialize_from_checkpoint)
def test_candidates_in_region_no_reads(self):
self.processor.in_memory_sam_reader = mock.Mock()
self.processor.in_memory_sam_reader.query.return_value = []
mock_ac = self.add_mock('_make_allele_counter_for_region')
self.assertEqual(([], []), self.processor.candidates_in_region(self.region))
self.processor.in_memory_sam_reader.query.assert_called_once_with(
self.region)
# A region with no reads should return out without making an AlleleCounter.
test_utils.assert_not_called_workaround(mock_ac)
def test_candidates_in_region_no_reads(self):
main_sample = self.processor.samples[0]
main_sample.in_memory_sam_reader.query.return_value = []
mock_ac = self.add_mock('_make_allele_counter_for_region')
self.assertEqual(({}, {}),
self.processor.candidates_in_region(self.region))
main_sample.in_memory_sam_reader.query.assert_called_once_with(
self.region)
# A region with no reads should return out without making an AlleleCounter.
test_utils.assert_not_called_workaround(mock_ac)
def test_process_calls_no_candidates(self):
self.processor.in_memory_sam_reader = mock.Mock()
mock_rr = self.add_mock('region_reads', retval=[])
mock_cir = self.add_mock('candidates_in_region', retval=([], []))
mock_cpe = self.add_mock('create_pileup_examples', retval=[])
mock_lc = self.add_mock('label_candidates')
self.assertEqual(([], [], []), self.processor.process(self.region))
mock_rr.assert_called_once_with(self.region)
self.processor.in_memory_sam_reader.replace_reads.assert_called_once_with(
[])
mock_cir.assert_called_once_with(self.region)
test_utils.assert_not_called_workaround(mock_cpe)
mock_lc.assert_called_once_with([])
def test_on_demand_initialization_not_called_if_initialized(self):
self.processor.initialized = True
self.assertTrue(self.processor.initialized)
self.processor.in_memory_sam_reader = mock.Mock()
mock_rr = self.add_mock('region_reads', retval=[])
mock_cir = self.add_mock('candidates_in_region', retval=([], []))
mock_lc = self.add_mock('label_candidates', retval=[])
self.processor.process(self.region)
test_utils.assert_not_called_workaround(self.mock_init)
mock_rr.assert_called_once_with(self.region)
self.processor.in_memory_sam_reader.replace_reads.assert_called_once_with(
[])
mock_cir.assert_called_once_with(self.region)
test_utils.assert_called_once_workaround(mock_lc)
def test_process_keeps_ordering_of_candidates_and_examples(self, mode):
self.processor.options.mode = mode
r1, r2 = mock.Mock(), mock.Mock()
c1, c2 = mock.Mock(), mock.Mock()
l1, l2 = mock.Mock(), mock.Mock()
e1, e2, e3 = mock.Mock(), mock.Mock(), mock.Mock()
main_sample = self.processor.samples[0]
self.add_mock('region_reads', retval=[r1, r2])
self.add_mock('candidates_in_region',
retval=({
'main_sample': [c1, c2]
}, {
'main_sample': []
}))
mock_cpe = self.add_mock('create_pileup_examples',
side_effect=[[e1], [e2, e3]])
mock_lc = self.add_mock('label_candidates',
retval=[(c1, l1), (c2, l2)])
mock_alte = self.add_mock('add_label_to_example',
side_effect=[e1, e2, e3])
candidates, examples, gvcfs, runtimes = self.processor.process(
self.region)
self.assertEqual(candidates['main_sample'], [c1, c2])
self.assertEqual(examples['main_sample'], [e1, e2, e3])
self.assertEmpty(gvcfs['main_sample'])
self.assertIsInstance(runtimes, dict)
main_sample.in_memory_sam_reader.replace_reads.assert_called_once_with(
[r1, r2])
# We don't try to label variants when in calling mode.
self.assertEqual(
[mock.call(c1, sample_order=[0]),
mock.call(c2, sample_order=[0])], mock_cpe.call_args_list)
if mode == deepvariant_pb2.MakeExamplesOptions.CALLING:
# In calling mode, we never try to label.
test_utils.assert_not_called_workaround(mock_lc)
test_utils.assert_not_called_workaround(mock_alte)
else:
mock_lc.assert_called_once_with([c1, c2], self.region)
self.assertEqual([
mock.call(e1, l1),
mock.call(e2, l2),
mock.call(e3, l2),
], mock_alte.call_args_list)
def test_process_calls_with_candidates(self, mode):
self.processor.options.mode = mode
main_sample = self.processor.samples[0]
mock_read = mock.MagicMock()
mock_candidate = mock.MagicMock()
mock_example = mock.MagicMock()
mock_label = mock.MagicMock()
mock_rr = self.add_mock('region_reads', retval=[mock_read])
mock_cir = self.add_mock('candidates_in_region',
retval=({
'main_sample': [mock_candidate]
}, {
'main_sample': []
}))
mock_cpe = self.add_mock('create_pileup_examples',
retval=[mock_example])
mock_lc = self.add_mock('label_candidates',
retval=[(mock_candidate, mock_label)])
mock_alte = self.add_mock('add_label_to_example', retval=mock_example)
candidates, examples, gvcfs, runtimes = self.processor.process(
self.region)
self.assertEqual(candidates['main_sample'], [mock_candidate])
self.assertEqual(examples['main_sample'], [mock_example])
self.assertEmpty(gvcfs['main_sample'])
self.assertIsInstance(runtimes, dict)
mock_rr.assert_called_once_with(
region=self.region,
sam_readers=None,
reads_filenames=main_sample.options.reads_filenames)
main_sample.in_memory_sam_reader.replace_reads.assert_called_once_with(
[mock_read])
mock_cir.assert_called_once_with(self.region)
mock_cpe.assert_called_once_with(mock_candidate, sample_order=[0])
if mode == deepvariant_pb2.MakeExamplesOptions.TRAINING:
mock_lc.assert_called_once_with([mock_candidate], self.region)
mock_alte.assert_called_once_with(mock_example, mock_label)
else:
# In training mode we don't label our candidates.
test_utils.assert_not_called_workaround(mock_lc)
test_utils.assert_not_called_workaround(mock_alte)
def test_process_with_realigner(self):
self.processor.options.mode = deepvariant_pb2.MakeExamplesOptions.CALLING
self.processor.options.realigner_enabled = True
self.processor.options.realigner_options.CopyFrom(
realigner_pb2.RealignerOptions())
self.processor.realigner = mock.Mock()
self.processor.realigner.realign_reads.return_value = [], []
main_sample = self.processor.samples[0]
main_sample.sam_readers = [mock.Mock()]
main_sample.sam_readers[0].query.return_value = []
c1, c2 = mock.Mock(), mock.Mock()
e1, e2, e3 = mock.Mock(), mock.Mock(), mock.Mock()
self.add_mock('candidates_in_region',
retval=({
'main_sample': [c1, c2]
}, {
'main_sample': []
}))
mock_cpe = self.add_mock('create_pileup_examples',
side_effect=[[e1], [e2, e3]])
mock_lc = self.add_mock('label_candidates')
candidates, examples, gvcfs, runtimes = self.processor.process(
self.region)
self.assertEqual(candidates['main_sample'], [c1, c2])
self.assertEqual(examples['main_sample'], [e1, e2, e3])
self.assertEmpty(gvcfs['main_sample'])
self.assertIsInstance(runtimes, dict)
main_sample.sam_readers[0].query.assert_called_once_with(self.region)
self.processor.realigner.realign_reads.assert_called_once_with(
[], self.region)
main_sample.in_memory_sam_reader.replace_reads.assert_called_once_with(
[])
self.assertEqual(
[mock.call(c1, sample_order=[0]),
mock.call(c2, sample_order=[0])], mock_cpe.call_args_list)
test_utils.assert_not_called_workaround(mock_lc)
def test_on_demand_initialization_not_called_if_initialized(self):
self.processor.initialized = True
self.assertTrue(self.processor.initialized)
main_sample = self.processor.samples[0]
mock_rr = self.add_mock('region_reads', retval=[])
mock_cir = self.add_mock('candidates_in_region',
retval=({
'main_sample': []
}, {
'main_sample': []
}))
mock_lc = self.add_mock('label_candidates', retval=[])
self.processor.process(self.region)
test_utils.assert_not_called_workaround(self.mock_init)
mock_rr.assert_called_once_with(
region=self.region,
sam_readers=None,
reads_filenames=main_sample.options.reads_filenames)
main_sample.in_memory_sam_reader.replace_reads.assert_called_once_with(
[])
mock_cir.assert_called_once_with(self.region)
test_utils.assert_called_once_workaround(mock_lc)
def test_adaptor_with_ownership(self, take_ownership):
mock_writer = mock.MagicMock()
adaptor = io.RawProtoWriterAdaptor(
mock_writer, take_ownership=take_ownership)
# Write out protos to our adaptor.
with adaptor as enter_return_value:
# Make sure that __enter__ returns the adaptor itself.
self.assertIs(adaptor, enter_return_value)
adaptor.write(self.proto1)
adaptor.write(self.proto2)
if take_ownership:
# If we took ownership, mock_writer __enter__ and __exit__ should have
# been called.
mock_writer.__enter__.assert_called_once_with()
test_utils.assert_called_once_workaround(mock_writer.__exit__)
else:
# If not, they shouldn't have been called.
test_utils.assert_not_called_workaround(mock_writer.__enter__)
test_utils.assert_not_called_workaround(mock_writer.__exit__)
self.assertEqual(mock_writer.write.call_args_list,
[mock.call(r.SerializeToString()) for r in self.protos])
