def test_adding_gene_save_source(self):
gps = GenePanelSnapshotFactory()
GenePanelEntrySnapshotFactory.create_batch(4, panel=gps)
gene = GeneFactory()
url = reverse_lazy('panels:add_entity',
kwargs={
'pk': gps.panel.pk,
'entity_type': 'gene'
})
gene_data = {
"gene":
gene.pk,
"source":
Evidence.OTHER_SOURCES[0],
"phenotypes":
"{};{};{}".format(*fake.sentences(nb=3)),
"rating":
Evaluation.RATINGS.AMBER,
"moi":
[x for x in Evaluation.MODES_OF_INHERITANCE][randint(1, 12)][0],
"mode_of_pathogenicity":
[x for x in Evaluation.MODES_OF_PATHOGENICITY][randint(1, 2)][0],
"penetrance":
GenePanelEntrySnapshot.PENETRANCE.Incomplete,
}
self.client.post(url, gene_data)
gpes = gps.panel.active_panel.get_gene(gene.gene_symbol)
self.assertTrue(gene_data['source'] in gpes.evaluation.get(
user=self.verified_user).comments.first().comment)
def test_adding_gene_create_activity(self):
gps = GenePanelSnapshotFactory()
GenePanelEntrySnapshotFactory.create_batch(4, panel=gps)
gene = GeneFactory()
url = reverse_lazy('panels:add_entity',
kwargs={
'pk': gps.panel.pk,
'entity_type': 'gene'
})
gene_data = {
"gene":
gene.pk,
"source":
Evidence.OTHER_SOURCES[0],
"phenotypes":
"{};{};{}".format(*fake.sentences(nb=3)),
"rating":
Evaluation.RATINGS.AMBER,
"moi":
[x for x in Evaluation.MODES_OF_INHERITANCE][randint(1, 12)][0],
"mode_of_pathogenicity":
[x for x in Evaluation.MODES_OF_PATHOGENICITY][randint(1, 2)][0],
"penetrance":
GenePanelEntrySnapshot.PENETRANCE.Incomplete,
}
req = self.client.post(url, gene_data)
self.assertEqual(Activity.objects.count(), 1)
def test_get_internal_panels_for_a_gene(self):
gene = GeneFactory()
gps = GenePanelSnapshotFactory(panel__status=GenePanel.STATUS.public)
GenePanelEntrySnapshotFactory.create_batch(2,
panel=gps) # random genes
GenePanelEntrySnapshotFactory.create(gene_core=gene, panel=gps)
gps2 = GenePanelSnapshotFactory(
panel__status=GenePanel.STATUS.internal)
GenePanelEntrySnapshotFactory.create_batch(2,
panel=gps2) # random genes
GenePanelEntrySnapshotFactory.create(gene_core=gene, panel=gps2)
gps3 = GenePanelSnapshotFactory(panel__status=GenePanel.STATUS.public)
GenePanelEntrySnapshotFactory.create_batch(2,
panel=gps3) # random genes
self.assertEqual(
GenePanelEntrySnapshot.objects.get_gene_panels(
gene.gene_symbol).count(), 2)
self.assertEqual(
GenePanelSnapshot.objects.get_gene_panels(
gene.gene_symbol).count(), 1)
self.assertEqual(
GenePanelSnapshot.objects.get_gene_panels(gene.gene_symbol,
all=True,
internal=True).count(),
2)
url = reverse_lazy('panels:entity_detail',
kwargs={'slug': gene.gene_symbol})
res = self.client.get(url)
self.assertEqual(len(res.context_data['entries']), 2)
def test_remove_publication(self):
"""Remove a publication to a gene panel entry"""
gpes = GenePanelEntrySnapshotFactory(
penetrance=GenePanelEntrySnapshot.PENETRANCE.Incomplete)
gpes.publications = [fake.sentence(), fake.sentence()]
gpes.save()
url = reverse_lazy('panels:edit_entity',
kwargs={
'pk': gpes.panel.panel.pk,
'entity_type': 'gene',
'entity_name': gpes.gene.get('gene_symbol')
})
gene_data = {
"gene": gpes.gene_core.pk,
"gene_name": "Gene name",
"source": set([ev.name for ev in gpes.evidence.all()]),
"tags": [tag.pk for tag in gpes.tags.all()],
"publications": ";".join(gpes.publications[:1]),
"phenotypes":
";".join([phenotype for phenotype in gpes.phenotypes]),
"moi": gpes.moi,
"mode_of_pathogenicity": gpes.mode_of_pathogenicity,
"penetrance": GenePanelEntrySnapshot.PENETRANCE.Complete,
}
res = self.client.post(url, gene_data)
assert res.status_code == 302
gene = GenePanel.objects.get(
pk=gpes.panel.panel.pk).active_panel.get_gene(
gpes.gene_core.gene_symbol)
assert gene.publications == gpes.publications[:1]
def test_import_panel_sources(self):
gene = GeneFactory(gene_symbol="ABCC5-AS1")
A1CF = GeneFactory(gene_symbol="A1CF")
GeneFactory(gene_symbol="STR_1")
gps = GenePanelSnapshotFactory()
gps.panel.name = "Panel One"
gps.level4title.name = gps.panel.name
gps.level4title.save()
gps.panel.save()
evidence = EvidenceFactory.create(name="Expert Review Amber")
GenePanelEntrySnapshotFactory.create(gene_core=gene,
panel=gps,
evaluation=(None, ),
evidence=(evidence, ))
self.assertEqual(
gps.get_gene(gene.gene_symbol).evidence.first().name,
"Expert Review Amber")
file_path = os.path.join(os.path.dirname(__file__),
'import_panel_data.tsv')
test_panel_file = os.path.abspath(file_path)
with open(test_panel_file) as f:
url = reverse_lazy('panels:upload_panels')
self.client.post(url, {'panel_list': f})
ap = GenePanel.objects.get(name="Panel One").active_panel
self.assertEqual(
ap.get_gene(gene.gene_symbol).evidence.first().name,
"Expert Review Green")
self.assertEqual(ap.get_gene(gene.gene_symbol).evidence.count(), 1)
self.assertEqual(sorted(ap.get_gene('A1CF').phenotypes),
sorted(['57h', 'wef']))
def test_export_activities_functionality(self):
gps = GenePanelSnapshotFactory()
GenePanelEntrySnapshotFactory.create_batch(4, panel=gps)
gene = GeneFactory()
url = reverse_lazy('panels:add_entity',
kwargs={
'pk': gps.panel.pk,
'entity_type': 'gene'
})
gene_data = {
"gene":
gene.pk,
"source":
Evidence.OTHER_SOURCES[0],
"phenotypes":
"{};{};{}".format(*fake.sentences(nb=3)),
"rating":
Evaluation.RATINGS.AMBER,
"moi":
[x for x in Evaluation.MODES_OF_INHERITANCE][randint(1, 12)][0],
"mode_of_pathogenicity":
[x for x in Evaluation.MODES_OF_PATHOGENICITY][randint(1, 2)][0],
"penetrance":
GenePanelEntrySnapshot.PENETRANCE.Incomplete,
}
self.client.post(url, gene_data)
activities_url = reverse(
'panels:activity') + '?format=csv&panel=' + str(gps.panel.pk)
res = self.client.get(activities_url)
self.assertTrue(gps.panel.name.encode() in res.content)
def test_mark_all_genes_not_ready(self):
gps = GenePanelSnapshotFactory()
GenePanelEntrySnapshotFactory.create_batch(5, ready=True, panel=gps)
assert GenePanelEntrySnapshot.objects.filter(ready=True).count() == 5
url = reverse_lazy('panels:mark_not_ready',
kwargs={'pk': gps.panel.pk})
res = self.client.get(url)
assert GenePanelEntrySnapshot.objects.filter(ready=True).count() == 0
assert res.status_code == 302
def test_gene_not_ready(self):
gpes = GenePanelEntrySnapshotFactory()
url = reverse_lazy('panels:mark_entity_as_not_ready',
args=(gpes.panel.panel.pk, 'gene',
gpes.gene.get('gene_symbol')))
r = self.client.post(url, {})
self.assertEqual(r.status_code, 302)
def test_form_should_be_prefilled(self):
gpes = GenePanelEntrySnapshotFactory()
gpes.evaluation.all().delete()
url = reverse_lazy('panels:review_entity',
kwargs={
'pk': gpes.panel.panel.pk,
'entity_type': 'gene',
'entity_name': gpes.gene.get('gene_symbol')
})
gene_data = {
"rating":
Evaluation.RATINGS.AMBER,
"current_diagnostic":
True,
"publications":
";".join([fake.sentence(), fake.sentence()]),
"moi":
[x for x in Evaluation.MODES_OF_INHERITANCE][randint(1, 12)][0],
"mode_of_pathogenicity":
[x for x in Evaluation.MODES_OF_PATHOGENICITY][randint(1, 2)][0],
}
self.client.post(url, gene_data)
url = reverse_lazy('panels:evaluation',
kwargs={
'pk': gpes.panel.panel.pk,
'entity_type': 'gene',
'entity_name': gpes.gene.get('gene_symbol')
})
res = self.client.get(url)
assert res.content.find(
str.encode('<option value="{}" selected>'.format(
gene_data['moi']))) != -1
def test_old_pk_redirect(self):
gpes = GenePanelEntrySnapshotFactory()
gpes.panel.panel.old_pk = fake.password(length=24,
special_chars=False,
upper_case=False)
gpes.panel.panel.save()
res = self.client.get(
reverse_lazy('panels:old_code_url_redirect',
args=(
gpes.panel.panel.old_pk,
'',
)))
self.assertEqual(res.status_code, 301)
self.assertEqual(
res.url, reverse_lazy('panels:detail',
args=(gpes.panel.panel.pk, )))
res = self.client.get(
reverse_lazy('panels:old_code_url_redirect',
args=(gpes.panel.panel.old_pk,
'gene/' + gpes.gene.get('gene_symbol'))))
self.assertEqual(res.status_code, 301)
self.assertEqual(
res.url + '/',
reverse_lazy('panels:evaluation',
args=(gpes.panel.panel.id, 'gene',
gpes.gene.get('gene_symbol'))))
def test_promote_panel(self):
gpes = GenePanelEntrySnapshotFactory()
data = {'version_comment': fake.sentence()}
url = reverse_lazy('panels:promote', args=(gpes.panel.panel.pk, ))
res = self.client.post(url, data)
self.assertEqual(res.status_code, 302)
def test_delete_gene(self):
gps = GenePanelSnapshotFactory()
genes = GenePanelEntrySnapshotFactory.create_batch(5, panel=gps)
gene_symbol = genes[2].gene['gene_symbol']
number_of_genes = gps.stats.get('number_of_genes')
assert gps.has_gene(gene_symbol) is True
gps = gps.panel.active_panel
gps.delete_gene(gene_symbol)
gps = gps.panel.active_panel
assert gps.panel.active_panel.has_gene(gene_symbol) is False
assert number_of_genes - 1 == gps.panel.active_panel.stats.get(
'number_of_genes') # 4 is due to create_batch
old_gps = GenePanel.objects.get(
pk=gps.panel.pk).genepanelsnapshot_set.last()
assert old_gps.version != gps.version
assert old_gps.has_gene(gene_symbol) is True
new_gps = GenePanel.objects.get(pk=gps.panel.pk).active_panel
assert new_gps.has_gene(gene_symbol) is False
gene_symbol = genes[3].gene['gene_symbol']
assert new_gps.has_gene(gene_symbol) is True
new_gps.delete_gene(gene_symbol, False)
assert new_gps.has_gene(gene_symbol) is False
new_gps = GenePanel.objects.get(pk=gps.panel.pk).active_panel
assert new_gps.has_gene(gene_symbol) is False
def test_str_data_copied(self):
gpes = GenePanelEntrySnapshotFactory()
active_panel = gpes.panel
str_item = active_panel.add_str(self.gel_user, 'ABC', {
'gene': gpes.gene_core,
'chromosome': '1',
'position_37': (12345, 12346),
'position_38': (12345, 12346),
'repeated_sequence': 'ATAT',
'normal_repeats': '2',
'pathogenic_repeats': '5',
'panel': active_panel,
'moi': 'X-LINKED: hemizygous mutation in males, biallelic mutations in females',
'penetrance': 'Incomplete',
'publications': None,
'phenotypes': None,
'sources': [],
})
active_panel = active_panel.panel.active_panel
assert active_panel.has_str(str_item.name)
active_panel.increment_version()
active_panel = active_panel.panel.active_panel
assert active_panel.panel.active_panel.has_str(str_item.name)
def test_specific_versions(self):
gpes = GenePanelEntrySnapshotFactory()
res = self.client.get(
'/crowdsourcing/WebServices/get_panel/{}?version=0.0'.format(
gpes.panel.id))
self.assertIn('version=0.0', res.url)
self.assertEqual(res.status_code, 301)
def test_add_evaluation_error(self):
"""Add comments"""
gpes = GenePanelEntrySnapshotFactory()
current_version = gpes.panel.version
gpes.evaluation.all().delete()
url = reverse_lazy('panels:review_entity',
kwargs={
'pk': gpes.panel.panel.pk,
'entity_type': 'gene',
'entity_name': gpes.gene.get('gene_symbol')
})
gene_data = {
"comments": fake.sentence(),
"publications": "1;",
"phenotypes": "2;",
}
res = self.client.post(url, gene_data)
assert res.status_code == 200
assert b'Make sure there is no ; if no value after: ' in res.content
gene_data = {
"comments": fake.sentence(),
"publications": "1",
"phenotypes": "2",
}
res = self.client.post(url, gene_data)
assert res.status_code == 302
v01gene = gpes.panel.panel.active_panel.get_gene(
gpes.gene.get('gene_symbol'))
assert v01gene.evaluation.get(user=self.gel_user).comments.count() == 1
def test_add_evaluation_comments_only(self):
"""Add comments"""
gpes = GenePanelEntrySnapshotFactory()
current_version = gpes.panel.version
gpes.evaluation.all().delete()
url = reverse_lazy('panels:review_entity',
kwargs={
'pk': gpes.panel.panel.pk,
'entity_type': 'gene',
'entity_name': gpes.gene.get('gene_symbol')
})
gene_data = {
"comments": fake.sentence(),
}
res = self.client.post(url, gene_data)
assert res.status_code == 302
v01gene = gpes.panel.panel.active_panel.get_gene(
gpes.gene.get('gene_symbol'))
assert v01gene.evaluation.get(user=self.gel_user).comments.count() == 1
gene_data = {
"comments": fake.sentence(),
}
res = self.client.post(url, gene_data)
assert v01gene.evaluation.get(user=self.gel_user).comments.count() == 2
assert current_version == gpes.panel.panel.active_panel.version
def test_update_publications(self):
gpes = GenePanelEntrySnapshotFactory()
gpes.evaluation.all().delete()
url = reverse_lazy('panels:update_entity_publications',
kwargs={
'pk': gpes.panel.panel.pk,
'entity_type': 'gene',
'entity_name': gpes.gene.get('gene_symbol')
})
publications_array = [fake.word(), fake.word()]
publications = "{}; {}".format(publications_array[0],
publications_array[1])
data = {'comment': fake.sentence(), 'publications': publications}
res = self.client.post(url,
data,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
gene = GenePanel.objects.get(
pk=gpes.panel.panel.pk).active_panel.get_gene(
gpes.gene.get('gene_symbol'))
assert res.json().get('status') == 200
assert Comment.objects.count() == 1
assert gene.publications == publications_array
assert gene.panel.version != gpes.panel.version
def test_update_gene_preserves_comments_order(self):
gpes = GenePanelEntrySnapshotFactory()
comments = list(CommentFactory.create_batch(4,
user=self.verified_user))
for ev in gpes.evaluation.all():
ev.comments.add(comments.pop())
max_comments_num = max(
[e.comments.count() for e in gpes.evaluation.all()])
self.assertEqual(1, max_comments_num)
old_gene_symbol = gpes.gene.get('gene_symbol')
new_gene = GeneFactory()
ap = GenePanel.objects.get(pk=gpes.panel.panel.pk).active_panel
new_data = {"gene": new_gene, "gene_name": "Other name"}
ap.update_gene(self.verified_user, old_gene_symbol, new_data)
new_ap = GenePanel.objects.get(pk=gpes.panel.panel.pk).active_panel
gpes = new_ap.get_gene(new_gene.gene_symbol)
max_comments_num_after_update = max(
[e.comments.count() for e in gpes.evaluation.all()])
self.assertEqual(1, max_comments_num_after_update)
def setUp(self):
super().setUp()
self.gpes = GenePanelEntrySnapshotFactory()
evidence = self.gpes.evidence.all()[0]
evidence.reviewer.user_type = 'GEL'
evidence.reviewer.save()
def test_delete_comment(self):
gpes = GenePanelEntrySnapshotFactory()
current_version = gpes.panel.version
evaluation_url = reverse_lazy('panels:review_entity',
kwargs={
'pk':
gpes.panel.panel.pk,
'entity_type':
'gene',
'entity_name':
gpes.gene.get('gene_symbol')
})
gene_data = {
"rating":
Evaluation.RATINGS.AMBER,
"current_diagnostic":
True,
"comments":
fake.sentence(),
"publications":
";".join([fake.sentence(), fake.sentence()]),
"phenotypes":
";".join([fake.sentence(),
fake.sentence(),
fake.sentence()]),
"moi":
[x for x in Evaluation.MODES_OF_INHERITANCE][randint(1, 12)][0],
"mode_of_pathogenicity":
[x for x in Evaluation.MODES_OF_PATHOGENICITY][randint(1, 2)][0],
}
self.client.post(evaluation_url,
gene_data,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
gene = GenePanel.objects.get(
pk=gpes.panel.panel.pk).active_panel.get_gene(
gpes.gene.get('gene_symbol'))
evaluation = gene.evaluation.get(user=self.gel_user)
assert evaluation.comments.count() == 1
delete_comment_url = reverse_lazy('panels:delete_comment_by_user',
kwargs={
'pk':
gpes.panel.panel.pk,
'entity_type':
'gene',
'entity_name':
gpes.gene.get('gene_symbol'),
'comment_pk':
evaluation.comments.first().pk
})
res = self.client.get(delete_comment_url,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
assert res.json().get('status') == 200
assert evaluation.comments.count() == 0
assert res.content.find(str.encode('Your review')) != -1
assert current_version == gpes.panel.panel.active_panel.version
def test_download_panel_contains_strs(self):
gpes = GenePanelEntrySnapshotFactory()
gps = gpes.panel
strs = STRFactory(repeated_sequence="ATATCGCGN", panel=gps)
res = self.client.get(reverse_lazy('panels:download_panel_tsv', args=(gps.panel.pk, '01234')))
self.assertEqual(res.status_code, 200)
self.assertTrue(res.content.find(strs.repeated_sequence.encode()) != 1)
def test_download_all_regions(self):
gpes = GenePanelEntrySnapshotFactory()
gps = gpes.panel
region = RegionFactory(panel=gps)
res = self.client.get(reverse_lazy('panels:download_regions'))
self.assertEqual(res.status_code, 200)
self.assertTrue(b"".join(res.streaming_content).find(
region.verbose_name.encode()) != 1)
def setUp(self):
super().setUp()
self.gps = GenePanelSnapshotFactory(
panel__status=GenePanel.STATUS.public)
self.gps_public = GenePanelSnapshotFactory(
panel__status=GenePanel.STATUS.public)
self.gpes = GenePanelEntrySnapshotFactory(panel=self.gps_public)
self.gpes_internal = GenePanelEntrySnapshotFactory(
panel__panel__status=GenePanel.STATUS.internal)
self.gpes_retired = GenePanelEntrySnapshotFactory(
panel__panel__status=GenePanel.STATUS.retired)
self.gpes_deleted = GenePanelEntrySnapshotFactory(
panel__panel__status=GenePanel.STATUS.deleted)
self.genes = GenePanelEntrySnapshotFactory.create_batch(4,
panel=self.gps)
self.str = STRFactory(panel__panel__status=GenePanel.STATUS.public)
self.region = RegionFactory(
panel__panel__status=GenePanel.STATUS.public)
def test_filter_by_panel_date_range(self):
gps = GenePanelSnapshotFactory(panel__status=GenePanel.STATUS.public)
GenePanelEntrySnapshotFactory.create_batch(4, panel=gps)
gene = GeneFactory()
url = reverse_lazy('panels:add_entity',
kwargs={
'pk': gps.panel.pk,
'entity_type': 'gene'
})
gene_data = {
"gene":
gene.pk,
"source":
Evidence.OTHER_SOURCES[0],
"phenotypes":
"{};{};{}".format(*fake.sentences(nb=3)),
"rating":
Evaluation.RATINGS.AMBER,
"moi":
[x for x in Evaluation.MODES_OF_INHERITANCE][randint(1, 12)][0],
"mode_of_pathogenicity":
[x for x in Evaluation.MODES_OF_PATHOGENICITY][randint(1, 2)][0],
"penetrance":
GenePanelEntrySnapshot.PENETRANCE.Incomplete,
}
self.client.post(url, gene_data)
now = timezone.now()
date_from = (now - timedelta(days=7)).strftime('%Y-%m-%d')
date_to = (now + timedelta(days=7)).strftime('%Y-%m-%d')
activities_url = reverse(
'panels:activity'
) + '?date_from=' + date_from + '&date_to=' + date_to
res = self.client.get(activities_url)
self.assertEqual(len(res.context['activities']), 1)
now = timezone.now() - timedelta(days=30)
date_from = (now - timedelta(days=7)).strftime('%Y-%m-%d')
date_to = (now + timedelta(days=7)).strftime('%Y-%m-%d')
activities_url = reverse(
'panels:activity'
) + '?date_from=' + date_from + '&date_to=' + date_to
res = self.client.get(activities_url)
self.assertEqual(len(res.context['activities']), 0)
def test_gene_evaluation(self):
gpes = GenePanelEntrySnapshotFactory()
url = reverse_lazy('panels:evaluation',
kwargs={
'pk': gpes.panel.panel.pk,
'entity_type': 'gene',
'entity_name': gpes.gene.get('gene_symbol')
})
res = self.client.get(url)
assert res.status_code == 200
def test_view_edit_gene_in_panel(self):
gpes = GenePanelEntrySnapshotFactory()
url = reverse_lazy('panels:edit_entity',
args=(
gpes.panel.panel.pk,
'gene',
gpes.gene.get('gene_symbol'),
))
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
def test_user_reviews(self):
gps = GenePanelSnapshotFactory()
gpes = GenePanelEntrySnapshotFactory.create_batch(10, panel=gps)
for g in gpes:
for evaluation in g.evaluation.all():
evaluation.user = self.verified_user
evaluation.save()
self.assertEqual(self.verified_user.get_recent_evaluations().count(),
35)
def test_download_panel_contains_regions(self):
gpes = GenePanelEntrySnapshotFactory()
gps = gpes.panel
RegionFactory(panel=gps)
res = self.client.get(
reverse_lazy('panels:download_panel_tsv',
args=(gps.panel.pk, '01234')))
self.assertEqual(res.status_code, 200)
self.assertTrue(res.content.find(b'region') != 1)
def test_evaluation_stays(self):
gps = GenePanelSnapshotFactory()
gpes = GenePanelEntrySnapshotFactory(panel=gps)
evaluations = gpes.evaluation.all()
gpes2 = GenePanelEntrySnapshotFactory(panel=gps)
evaluations2 = sorted(gpes2.evaluation.all().values_list('pk',
flat=True))
gps = gps.increment_version()
gps.update_gene(self.gel_user, gpes.gene_core.gene_symbol,
{'phenotypes': [
'abra',
]})
del gps.panel.active_panel
current_ev2 = sorted(
gps.panel.active_panel.get_gene(
gpes2.gene_core.gene_symbol).evaluation.all().values_list(
'pk', flat=True))
self.assertNotEqual(evaluations2, current_ev2)
def test_download_panel(self):
gene, gps, gps2 = self.prepare_compare()
grey_gene = 'gene2'
gene2 = GeneFactory(gene_symbol=grey_gene)
gpes = GenePanelEntrySnapshotFactory.create(gene_core=gene2, panel=gps)
gpes.saved_gel_status = 0
res = self.client.get(
reverse_lazy('panels:download_panel_tsv',
args=(gps.panel.pk, '01234')))
self.assertEqual(res.status_code, 200)
self.assertEqual(res.content.find(grey_gene.encode()), -1)
