def test_add_task_contrast(self):
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
task = Task()
condition = Condition()
tsk = task.create('test_add_task_contrast', {'prop': 'prop'})
cond1 = condition.create('test_add_task_contrast_cond1',
{'prop': 'prop'})
cond2 = condition.create('test_add_task_contrast_cond2',
{'prop': 'prop'})
cond_names = [
'test_add_task_contrast_cond1', 'test_add_task_contrast_cond2'
]
task.link(tsk.properties['id'],
cond1.properties['id'],
'HASCONDITION',
endnode_type='condition')
task.link(tsk.properties['id'],
cond2.properties['id'],
'HASCONDITION',
endnode_type='condition')
response = self.client.get(
reverse('add_task_contrast', kwargs={'uid': tsk.properties['id']}))
self.assertEqual(response.status_code, 200)
self.assertIn(response.context['conditions'][0]['condition_name'],
cond_names)
self.assertIn(response.context['conditions'][1]['condition_name'],
cond_names)
self.assertEqual(len(response.context['conditions']), 2)
tsk.delete_related()
tsk.delete()
cond1.delete()
cond2.delete()
def test_add_task_concept(self):
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
task = Task()
concept = Concept()
contrast = Contrast()
tsk = task.create('test_add_task_concept', {'prop': 'prop'})
con = concept.create('test_add_task_concept', {'prop': 'prop'})
cont = contrast.create('test_add_task_concept', {'prop': 'prop'})
concept.link(con.properties['id'],
cont.properties['id'],
"HASCONTRAST",
endnode_type='contrast')
response = self.client.post(
reverse('add_task_concept', kwargs={'uid': tsk.properties['id']}),
{'concept_selection': con.properties['id']})
self.assertEqual(response.status_code, 200)
response = self.client.get(
reverse('task', kwargs={'uid': tsk.properties['id']}))
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.context['task']['relations']['ASSERTS']),
1)
self.assertEqual(
response.context['task']['relations']['ASSERTS'][0]['id'],
con.properties['id'])
tsk.delete_related()
con.delete_related()
tsk.delete()
con.delete()
cont.delete()
def test_view_task(self):
task = Task()
tsk = task.create("test_view_task", {
"prop": "prop",
"definition": "definition"
})
uid = tsk.properties['id']
response = self.client.get(reverse('task', kwargs={'uid': uid}))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['task']['id'], uid)
# should also test linked concepts and contrasts
tsk.delete()
def test_update_task(self):
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
task = Task()
tsk = task.create('test_update_task', {'prop': 'prop'})
response = self.client.post(
reverse('update_task', kwargs={'uid': tsk.properties['id']}),
{'definition_text': 'new def'})
self.assertEqual(response.status_code, 200)
self.assertEqual('new def',
response.context['task']['definition_text'])
tsk.delete()
def test_add_task_indicator(self):
task = Task()
tsk = task.create('test_add_task_indicator', {'prop': 'prop'})
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
data = {
'type': 'add_task_indicator',
}
response = self.client.post(
reverse('add_task_indicator',
kwargs={'task_id': tsk.properties['id']}), data)
self.assertEqual(response.status_code, 200)
ind = task.get_relation(tsk.properties['id'], "HASINDICATOR")
self.assertEqual(len(ind), 1)
self.assertEqual(ind[0]['name'], 'add_task_indicator')
tsk.delete_related()
tsk.delete()
ind = graph.find_one("indicator", "id", ind[0]['id'])
def test_add_task_dataset(self):
task = Task()
tsk = task.create('test_add_task_dataset', {'prop': 'prop'})
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
data = {
'dataset_uri': 'http://example.com',
'dataset_name': 'add_task_dataset',
}
response = self.client.post(
reverse('add_task_dataset',
kwargs={'task_id': tsk.properties['id']}), data)
self.assertEqual(response.status_code, 200)
ds = task.get_relation(tsk.properties['id'], "HASEXTERNALDATASET")
self.assertEqual(len(ds), 1)
self.assertEqual(ds[0]['name'], 'add_task_dataset')
tsk.delete_related()
tsk.delete()
ds = graph.find_one("external_dataset", "id", ds[0]['id'])
def add_term(request):
'''add_term will add a new term to the atlas
'''
if request.method == "POST":
term_type = request.POST.get('term_type', '')
term_name = request.POST.get('term_name', '')
definition_text = request.POST.get('definition_text', '')
properties = None
if definition_text != '':
properties = {"definition": definition_text}
if term_type == "concept":
node = Concept.create(name=term_name, properties=properties)
return view_concept(request, node["id"])
elif term_type == "task":
node = Task.create(name=term_name, properties=properties)
return view_task(request, node["id"])
def test_add_task_implementation(self):
task = Task()
tsk = task.create('test_add_task_implementation', {'prop': 'prop'})
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
data = {
'implementation_uri': 'http://example.com',
'implementation_name': 'add_task_implementation',
'implementation_description': 'task imp desc'
}
response = self.client.post(
reverse('add_task_implementation',
kwargs={'task_id': tsk.properties['id']}), data)
self.assertEqual(response.status_code, 200)
imp = task.get_relation(tsk.properties['id'], "HASIMPLEMENTATION")
self.assertEqual(len(imp), 1)
self.assertEqual(imp[0]['name'], 'add_task_implementation')
tsk.delete_related()
tsk.delete()
imp = graph.find_one("implementation", "id", imp[0]['id'])
def test_add_condition(self):
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
task = Task()
condition = Condition()
tsk = task.create("test_add_condition_task", {
"prop": "prop",
"definition": "definition"
})
uid = tsk.properties['id']
response = self.client.post(
reverse('add_condition', kwargs={'task_id': uid}),
{'condition_name': 'test_add_condition'})
self.assertEqual(response.status_code, 200)
relation = task.get_conditions(uid)
self.assertEqual(len(relation), 1)
self.assertEqual(relation[0]['condition_name'], 'test_add_condition')
con = condition.graph.find_one('condition', 'id',
relation[0]['condition_id'])
tsk.delete_related()
tsk.delete()
con.delete()
def setUp(self):
task = Task()
self.task = task.create("test_view_task", {
"prop": "prop",
"definition": "definition"
})
class GraphUtilsTest(TestCase):
def setUp(self):
self.task = Task()
self.node_name = "test_name"
self.node_properties = {'test_key': 'test_value'}
self.graph = Graph("http://graphdb:7474/db/data/")
self.task1 = self.task.create(
name=self.node_name,
properties=self.node_properties)
self.task2 = self.task.create(
name=self.node_name,
properties=self.node_properties)
condition = Condition()
self.cond = condition.create(
name=self.node_name,
properties=self.node_properties)
contrast = Contrast()
self.cont = contrast.create(
name=self.node_name,
properties=self.node_properties)
concept = Concept()
self.con = concept.create(
name=self.node_name,
properties=self.node_properties)
self.task.link(
self.task1.properties['id'],
self.cond.properties['id'],
"HASCONDITION",
endnode_type='condition')
self.task.link(
self.task1.properties['id'],
self.con.properties['id'],
"ASSERTS",
endnode_type='concept')
condition.link(
self.cond.properties['id'],
self.cont.properties['id'],
"HASCONTRAST",
endnode_type='contrast')
concept.link(
self.con.properties['id'],
self.cont.properties['id'],
"MEASUREDBY",
endnode_type='contrast')
def tearDown(self):
self.task1.delete_related()
self.task2.delete_related()
self.cond.delete_related()
self.cont.delete_related()
self.con.delete_related()
self.task1.delete()
self.task2.delete()
self.cond.delete()
self.cont.delete()
self.con.delete()
def test_search(self):
# we create 5 nodes all with the same name, this should find them all
result = search('test_name')
self.assertEqual(len(result), 5)
'''
def test_get(self):
result = get(self.task1.properties['name'])
self.assertEqual(len(result), 1)
'''
''' ignoring gist functions for now
class NodeChildrenTest(TestCase):
def setUp(self):
self.task = Task()
self.node_name = "test_name"
self.node_properties = {'test_key': 'test_value'}
self.graph = Graph("http://graphdb:7474/db/data/")
self.task1 = self.task.create(
name=self.node_name,
properties=self.node_properties)
self.task2 = self.task.create(
name=self.node_name,
properties=self.node_properties)
condition = Condition()
self.cond = condition.create(
name=self.node_name,
properties=self.node_properties)
contrast = Contrast()
self.cont = contrast.create(
name=self.node_name,
properties=self.node_properties)
concept = Concept()
self.con = concept.create(
name=self.node_name,
properties=self.node_properties)
self.task.link(
self.task1.properties['id'],
self.cond.properties['id'],
"HASCONDITION",
endnode_type='condition')
self.task.link(
self.task1.properties['id'],
self.con.properties['id'],
"ASSERTS",
endnode_type='concept')
condition.link(
self.cond.properties['id'],
self.cont.properties['id'],
"HASCONTRAST",
endnode_type='contrast')
concept.link(
self.con.properties['id'],
self.cont.properties['id'],
"MEASUREDBY",
endnode_type='contrast')
def tearDown(self):
self.task1.delete_related()
self.task2.delete_related()
self.cond.delete_related()
self.cont.delete_related()
self.con.delete_related()
self.task1.delete()
self.task2.delete()
self.cond.delete()
self.cont.delete()
self.con.delete()
def test_task_get_contrasts(self):
contrasts = self.task.get_contrasts(self.task1.properties['id'])
self.assertEqual(len(contrasts), 1)
self.assertEqual(
contrasts[0]['contrast_id'],
self.cont.properties['id'])
def test_task_get_conditions(self):
conditions = self.task.get_conditions(self.task1.properties['id'])
self.assertEqual(len(conditions), 1)
self.assertEqual(
conditions[0]['condition_id'],
self.cond.properties['id'])
def test_contrast_get_conditions(self):
contrast = Contrast()
conditions = contrast.get_conditions(self.cont.properties['id'])
self.assertEqual(len(conditions), 1)
self.assertEqual(
conditions[0]['condition_id'],
self.cond.properties['id'])
def test_contrast_get_concepts(self):
contrast = Contrast()
concepts = contrast.get_concepts(self.cont.properties['id'])
self.assertEqual(len(concepts), 1)
self.assertEqual(concepts[0]['concept_id'], self.con.properties['id'])
def test_contrast_get_tasks(self):
contrast = Contrast()
tasks = contrast.get_tasks(self.cont.properties['id'])
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0]['task_id'], self.task1.properties['id'])
