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_multiple_parent_panels(self):
"""
Test updates to the test panels, and make sure parent panels are updated correctly
"""
gene1 = GeneFactory()
gene2 = GeneFactory()
gene3 = GeneFactory()
gene1_data = {
"gene":
gene1.pk,
"sources": [
Evidence.OTHER_SOURCES[0],
],
"phenotypes":
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,
"current_diagnostic":
False,
}
gene2_data = {
"gene":
gene2.pk,
"sources": [
Evidence.OTHER_SOURCES[2],
],
"phenotypes":
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,
"current_diagnostic":
False,
}
gene3_data = {
"gene":
gene3.pk,
"sources": [
Evidence.OTHER_SOURCES[3],
],
"phenotypes":
fake.sentences(nb=3),
"rating":
Evaluation.RATINGS.GREEN,
"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,
"current_diagnostic":
True,
}
child1 = GenePanelSnapshotFactory(
panel__status=GenePanel.STATUS.public)
child2 = GenePanelSnapshotFactory(
panel__status=GenePanel.STATUS.public)
child3 = GenePanelSnapshotFactory(
panel__status=GenePanel.STATUS.public)
parent = GenePanelSnapshotFactory(
panel__status=GenePanel.STATUS.public)
parent.child_panels.set([child1, child2])
parent.update_saved_stats()
self.assertEqual(parent.version, "0.0")
parent2 = GenePanelSnapshotFactory(
panel__status=GenePanel.STATUS.public)
parent2.child_panels.set([child2, child3])
parent2.update_saved_stats()
self.assertEqual(parent2.version, "0.0")
child1.add_gene(self.gel_user, gene1.gene_symbol, gene1_data)
child1.add_gene(self.gel_user, gene2.gene_symbol, gene2_data)
self.assertEqual(child1.version, "0.2")
parent = parent.panel.active_panel
self.assertEqual(parent.version, "0.2")
parent2 = parent2.panel.active_panel
self.assertEqual(parent2.version, "0.0")
child2.add_gene(self.gel_user, gene2.gene_symbol, gene2_data)
del child2.panel.active_panel
child2 = child2.panel.active_panel
self.assertEqual(child2.version, "0.1")
del parent.panel.active_panel
parent = parent.panel.active_panel
self.assertEqual(parent.version, "0.3")
del parent2.panel.active_panel
parent2 = parent2.panel.active_panel
self.assertEqual(parent2.version, "0.1")
child3.add_gene(self.gel_user, gene3.gene_symbol, gene3_data)
self.assertEqual(child3.version, "0.1")
del parent.panel.active_panel
parent = parent.panel.active_panel
old_stats = parent.stats
self.assertEqual(parent.version, "0.3")
del parent2.panel.active_panel
parent2 = parent2.panel.active_panel
self.assertEqual(parent2.version, "0.2")
child2.increment_version()
child2.update_gene(
self.gel_user, gene2.gene_symbol, {
"gene":
gene2,
"sources": [
Evidence.OTHER_SOURCES[1],
],
"phenotypes":
fake.sentences(nb=2),
"rating":
Evaluation.RATINGS.GREEN,
"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,
"current_diagnostic":
True,
}).update_rating(3, self.gel_user, '')
child2.update_saved_stats()
self.assertEqual(child1.version, "0.2")
self.assertEqual(child2.version, "0.2")
self.assertEqual(child3.version, "0.1")
del parent.panel.active_panel
parent = parent.panel.active_panel
self.assertEqual(parent.version, "0.4")
self.assertNotEqual(old_stats, parent.stats)
del parent2.panel.active_panel
parent2 = parent2.panel.active_panel
self.assertEqual(parent2.version, "0.3")
def test_increment_child_version(self):
gene1 = GeneFactory()
gene2 = GeneFactory()
parent = GenePanelSnapshotFactory(
panel__status=GenePanel.STATUS.public)
gene1_data = {
"gene":
gene1.pk,
"sources": [
Evidence.OTHER_SOURCES[0],
],
"phenotypes":
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,
"current_diagnostic":
False,
}
gene2_data = {
"gene":
gene2.pk,
"sources": [
Evidence.OTHER_SOURCES[0],
],
"phenotypes":
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,
"current_diagnostic":
False,
}
child1 = GenePanelSnapshotFactory(
panel__status=GenePanel.STATUS.public)
initial_child1_pk = child1.pk
child1.add_gene(self.gel_user, gene1.gene_symbol, gene1_data)
child1 = child1.panel.active_panel
child1.add_gene(self.gel_user, gene2.gene_symbol, gene2_data)
child1 = child1.panel.active_panel
self.assertNotEqual(initial_child1_pk, child1.pk)
child2 = GenePanelSnapshotFactory(
panel__status=GenePanel.STATUS.public)
initial_child2_pk = child2.pk
child2.add_gene(self.gel_user, gene1.gene_symbol, gene1_data)
child2 = child2.panel.active_panel
self.assertNotEqual(initial_child2_pk, child2.pk)
parent.child_panels.set([child1, child2])
parent.update_saved_stats()
old_parent = parent
child1.increment_version()
child1 = child1.panel.active_panel
child1.update_gene(
self.gel_user, gene2.gene_symbol, {
"gene":
gene2,
"sources": [
Evidence.OTHER_SOURCES[1],
],
"phenotypes":
fake.sentences(nb=3),
"rating":
Evaluation.RATINGS.GREEN,
"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,
"current_diagnostic":
False,
})
child1.get_gene(gene2.gene_symbol).update_rating(3, self.gel_user, '')
child1 = child1.panel.active_panel
parent = parent.panel.active_panel
parent.update_saved_stats()
self.assertNotEqual(parent, old_parent)
self.assertNotEqual(old_parent.stats, parent.stats)
self.assertIn(child1, parent.child_panels.all())
self.assertIn(child2, parent.child_panels.all())
self.assertEqual(child1.genepanelsnapshot_set.count(), 1)
self.assertEqual(
child2.genepanelsnapshot_set.count(),
2) # contains reference to two versions of parent panel
class TestAPIV1(LoginExternalUser):
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,
panel=self.gps)
STRFactory(panel__panel__status=GenePanel.STATUS.public)
self.region = RegionFactory(
panel__panel__status=GenePanel.STATUS.public, panel=self.gps)
RegionFactory(panel__panel__status=GenePanel.STATUS.public)
def test_list_panels(self):
r = self.client.get(reverse_lazy('api:v1:panels-list'))
self.assertEqual(r.status_code, 200)
def test_read_only_list_of_panels(self):
r = self.client.post(reverse_lazy('api:v1:panels-list'),
{'something': 'something'})
self.assertEqual(r.status_code, 405)
def test_list_panels_name(self):
url = reverse_lazy('api:v1:panels-list')
r = self.client.get(url)
self.assertEqual(len(r.json()['results']), 4)
self.assertEqual(r.status_code, 200)
def test_list_panels_filter_types(self):
panel_type = PanelTypeFactory()
self.gps.panel.types.add(panel_type)
url = reverse_lazy('api:v1:panels-list') + '?type=' + panel_type.slug
r = self.client.get(url)
json_res = r.json()['results']
self.assertEqual(json_res[0]['types'][0]['name'], panel_type.name)
self.assertEqual(r.status_code, 200)
def test_retired_panels(self):
url = reverse_lazy('api:v1:panels-list')
self.gps.panel.status = GenePanel.STATUS.deleted
self.gps.panel.save()
r = self.client.get(url)
self.assertEqual(len(r.json()['results']), 3)
self.assertEqual(r.status_code, 200)
# Test deleted panels
url = reverse_lazy('api:v1:panels-list')
r = self.client.get("{}?retired=True".format(url))
self.assertEqual(len(r.json()['results']),
4) # one for gpes via factory, 2nd - retired
self.assertEqual(r.status_code, 200)
# Test for unapproved panels
self.gps_public.panel.status = GenePanel.STATUS.internal
self.gps_public.panel.save()
url = reverse_lazy('api:v1:panels-list')
r = self.client.get("{}?retired=True".format(url))
self.assertEqual(len(r.json()['results']),
3) # only retired panel will be visible
self.assertEqual(r.status_code, 200)
def test_internal_panel(self):
self.gps.panel.status = GenePanel.STATUS.internal
self.gps.panel.save()
url = reverse_lazy('api:v1:panels-detail', args=(self.gps.panel.pk, ))
r = self.client.get(url)
self.assertEqual(r.status_code, 404)
self.assertEqual(r.json(), {'detail': 'Not found.'})
new_version = self.gps.increment_version()
self.gps.panel.active_panel.increment_version()
r = self.client.get("{}?version=0.1".format(url))
self.assertEqual(r.status_code, 200)
def test_get_panel_name(self):
r = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(self.gpes.panel.panel.name, )))
self.assertEqual(r.status_code, 200)
def test_get_panel_name_deleted(self):
r = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(self.gpes_deleted.panel.panel.name, )))
self.assertEqual(r.status_code, 404)
self.assertEqual(r.json(), {'detail': 'Not found.'})
def test_get_panel_internal(self):
r = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(self.gpes_internal.panel.panel.name, )))
self.assertEqual(r.status_code, 404)
self.assertEqual(r.json(), {'detail': 'Not found.'})
def test_get_panel_retired(self):
r = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(self.gpes_retired.panel.panel.name, )))
self.assertEqual(r.status_code, 404)
self.assertEqual(r.json(), {'detail': 'Not found.'})
def test_get_panel_pk(self):
r = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(self.gpes.panel.panel.pk, )))
self.assertEqual(r.status_code, 200)
def test_get_panel_version(self):
self.gpes.panel.increment_version()
self.gpes.panel.panel.active_panel.increment_version()
url = reverse_lazy('api:v1:panels-detail',
args=(self.gpes.panel.panel.pk, ))
r = self.client.get("{}?version=0.1".format(url))
self.assertEqual(r.status_code, 200)
self.gps.panel.status = GenePanel.STATUS.retired
self.gps.panel.save()
url = reverse_lazy('api:v1:panels-detail',
args=(self.gpes.panel.panel.pk, ))
r = self.client.get("{}?version=0.1".format(url))
self.assertEqual(r.status_code, 200)
self.assertTrue(b'Query Error' not in r.content)
def test_panel_created_timestamp(self):
self.gpes.panel.increment_version()
url = reverse_lazy('api:v1:panels-list')
res = self.client.get(url)
# find gps panel
title = self.gps_public.level4title.name
current_time = str(self.gps_public.created).replace('+00:00',
'Z').replace(
' ', 'T')
gps_panel = [r for r in res.json()['results'] if r['name'] == title][0]
self.assertEqual(gps_panel['version_created'], current_time)
r = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(gps_panel['id'], ))).json()
self.assertEqual(r['version_created'], current_time)
def test_get_search_gene(self):
url = reverse_lazy('api:v1:genes-detail',
args=(self.gpes.gene_core.gene_symbol, ))
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
def test_search_by_gene(self):
url = reverse_lazy('api:v1:genes-detail',
args=(self.gpes.gene_core.gene_symbol, ))
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
r = self.client.get("{}?panel_name={}".format(
url, self.gps_public.level4title.name))
self.assertEqual(r.status_code, 200)
multi_genes_arg = "{},{}".format(self.genes[0].gene_core.gene_symbol,
self.genes[1].gene_core.gene_symbol)
multi_genes_url = reverse_lazy('api:v1:genes-detail',
args=(multi_genes_arg, ))
r = self.client.get(multi_genes_url)
self.assertEqual(r.status_code, 200)
def test_strs_in_panel(self):
r = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(self.str.panel.panel.pk, )))
self.assertEqual(r.status_code, 200)
self.assertEqual(r.json()['strs'][0]['entity_name'], self.str.name)
self.assertEqual(
r.json()['strs'][0]['grch37_coordinates'],
[self.str.position_37.lower, self.str.position_37.upper])
self.assertEqual(
r.json()['strs'][0]['grch38_coordinates'],
[self.str.position_38.lower, self.str.position_38.upper])
self.assertEqual(r.json()['strs'][0]['pathogenic_repeats'],
self.str.pathogenic_repeats)
def test_genes_in_panel(self):
r = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(self.gpes.panel.panel.pk, )))
self.assertEqual(r.status_code, 200)
self.assertEqual(r.json()['genes'][0]['entity_name'],
self.gpes.gene.get('gene_symbol'))
self.assertEqual(r.json()['genes'][0]['mode_of_pathogenicity'],
self.gpes.mode_of_pathogenicity)
def test_genes_in_panel_version(self):
gene_symbol = self.gpes.gene.get('gene_symbol')
self.gps_public.delete_gene(gene_symbol)
self.gps_public = self.gps_public.panel.active_panel
r = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(self.gpes.panel.panel.pk, )) + '?version=0.0')
j = r.json()
self.assertEqual(r.status_code, 200)
gene_symbols_v0 = [g['entity_name'] for g in j['genes']]
self.assertTrue(gene_symbols_v0, gene_symbol)
r = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(self.gpes.panel.panel.pk, )) + '?version=0.1')
j = r.json()
self.assertEqual(r.status_code, 200)
gene_symbols_v0 = [g['entity_name'] for g in j['genes']]
self.assertFalse(gene_symbols_v0, gene_symbol)
def test_green_genes_panel(self):
# get all genes and their confidence levels counts
r = self.client.get(
reverse_lazy('api:v1:panels_genes-list',
args=(self.gps.panel_id, )) + '?confidence_level=3')
j = r.json()
green_db = [
e for e in self.gps.get_all_genes if e.saved_gel_status >= 3
]
green_api = [
e for e in j['results'] if int(e.get('confidence_level')) >= 3
]
self.assertEqual(len(green_db), len(green_api))
r = self.client.get(
reverse_lazy('api:v1:panels_genes-list',
args=(self.gps.panel_id, )) + '?confidence_level=2')
j = r.json()
amber_db = [
e for e in self.gps.get_all_genes if e.saved_gel_status == 2
]
amber_api = [
e for e in j['results'] if int(e.get('confidence_level')) == 2
]
self.assertEqual(len(amber_db), len(amber_api))
r = self.client.get(
reverse_lazy('api:v1:panels_genes-list',
args=(self.gps.panel_id, )) + '?confidence_level=1')
j = r.json()
red_db = [e for e in self.gps.get_all_genes if e.saved_gel_status == 1]
red_api = [
e for e in j['results'] if int(e.get('confidence_level')) == 1
]
self.assertEqual(len(red_db), len(red_api))
def test_genes_endpoint_in_panel_version(self):
gene_symbol = self.gpes.gene.get('gene_symbol')
self.gps_public.delete_gene(gene_symbol)
self.gps_public = self.gps_public.panel.active_panel
r = self.client.get(
reverse_lazy('api:v1:panels_genes-list',
args=(self.gpes.panel.panel.pk, )) + '?version=0.0')
j = r.json()
self.assertEqual(r.status_code, 200)
gene_symbols_v0 = [g['entity_name'] for g in j['results']]
self.assertTrue(gene_symbols_v0, gene_symbol)
r = self.client.get(
reverse_lazy('api:v1:panels_genes-list',
args=(self.gpes.panel.panel.pk, )) + '?version=0.1')
j = r.json()
self.assertEqual(r.status_code, 200)
gene_symbols_v0 = [g['entity_name'] for g in j['results']]
self.assertFalse(gene_symbols_v0, gene_symbol)
def test_genes_endpoint_entities_name(self):
gene_symbol1 = self.genes[0].gene.get('gene_symbol')
gene_symbol2 = self.genes[1].gene.get('gene_symbol')
r = self.client.get(
reverse_lazy('api:v1:panels_genes-list',
args=(self.gps.panel_id, )) +
'?entity_name={},{}'.format(gene_symbol1, gene_symbol2))
j = r.json()
self.assertEqual(r.status_code, 200)
gene_symbols = [g['entity_name'] for g in j['results']]
self.assertTrue(len(j['results']), 2)
self.assertTrue(gene_symbol1 in gene_symbols)
self.assertTrue(gene_symbol2 in gene_symbols)
def test_region_in_panel(self):
r = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(self.region.panel.panel.pk, )))
self.assertEqual(r.status_code, 200)
region = r.json()['regions'][0]
self.assertEqual(region['entity_name'], self.region.name)
self.assertEqual(
region['grch37_coordinates'],
[self.region.position_37.lower, self.region.position_37.upper])
self.assertEqual(
region['grch38_coordinates'],
[self.region.position_38.lower, self.region.position_38.upper])
self.assertEqual(region['triplosensitivity_score'],
self.region.triplosensitivity_score)
def test_super_panel(self):
super_panel = GenePanelSnapshotFactory(
panel__status=GenePanel.STATUS.public)
super_panel.child_panels.set([
self.gps_public,
])
r_direct = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(self.gps_public.panel.pk, )))
result_genes = list(
sorted(r_direct.json()['genes'],
key=lambda x: x.get('gene_symbol')))
r = self.client.get(
reverse_lazy('api:v1:panels-detail',
args=(super_panel.panel.pk, )))
self.assertEqual(r.status_code, 200)
self.assertEqual(
result_genes,
list(sorted(r.json()['genes'],
key=lambda x: x.get('gene_symbol'))))
def test_evaluations(self):
r = self.client.get(
reverse_lazy('api:v1:genes-evaluations-list',
args=(self.gpes.panel.panel.pk,
self.gpes.gene_core.gene_symbol)))
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.json()['results']), 4)
def test_region_evaluations(self):
r = self.client.get(
reverse_lazy('api:v1:regions-evaluations-list',
args=(self.region.panel.panel.pk, self.region.name)))
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.json()['results']), 4)
def test_genes_list(self):
r = self.client.get(reverse_lazy('api:v1:genes-list'))
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.json()['results']), 5)
def test_genes_list_filter_types(self):
panel_type = PanelTypeFactory()
self.gps.panel.types.add(panel_type)
r = self.client.get(
reverse_lazy('api:v1:genes-list') + '?type=' + panel_type.slug)
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.json()['results']), 4)
def test_genes_list_filter_name(self):
r = self.client.get(
reverse_lazy('api:v1:genes-detail',
args=(self.gpes.gene_core.gene_symbol, )))
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.json()['results']), 1)
def test_strs_list(self):
r = self.client.get(reverse_lazy('api:v1:strs-list'))
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.json()['results']), 2)
def test_strs_list_filter_types(self):
panel_type = PanelTypeFactory()
self.gps.panel.types.add(panel_type)
r = self.client.get(
reverse_lazy('api:v1:strs-list') + '?type=' + panel_type.slug)
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.json()['results']), 1)
def test_regions_list(self):
r = self.client.get(reverse_lazy('api:v1:regions-list'))
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.json()['results']), 2)
def test_regions_list_filter_types(self):
panel_type = PanelTypeFactory()
self.gps.panel.types.add(panel_type)
r = self.client.get(
reverse_lazy('api:v1:regions-list') + '?type=' + panel_type.slug)
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.json()['results']), 1)
def test_entities_list(self):
r = self.client.get(reverse_lazy('api:v1:entities-list'))
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.json()['results']), 9)
def test_read_only_list_of_entities(self):
r = self.client.post(reverse_lazy('api:v1:entities-list'),
{'something': 'something'})
self.assertEqual(r.status_code, 405)
def test_entities_list_filter_name(self):
r = self.client.get(
reverse_lazy('api:v1:entities-detail', args=(self.region.name, )))
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.json()['results']), 1)
def test_entities_list_filter_types(self):
panel_type = PanelTypeFactory()
self.gps.panel.types.add(panel_type)
url = reverse_lazy('api:v1:entities-list') + '?type=' + panel_type.slug
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.json()['results']), 6)
