def test_populate_dataset_select(self):
d1 = Dataset(code=md.d1_code, name=md.d1_name, file_path=md.d1_file_path, query_params=md.d1_query_params)
db.session.add(d1)
d2 = Dataset(code=md.d2_code, name=md.d2_name, file_path=md.d2_file_path, query_params=md.d2_query_params)
db.session.add(d2)
dt1 = DatasetTracts(dataset_code=md.d1_code, method_code=md.m1_code, tract_code=md.t1_code)
db.session.add(dt1)
dt2 = DatasetTracts(dataset_code=md.d1_code, method_code=md.m2_code, tract_code=md.t1_code)
db.session.add(dt2)
dt3 = DatasetTracts(dataset_code=md.d2_code, method_code=md.m1_code, tract_code=md.t1_code)
db.session.add(dt3)
db.session.commit()
# get response
resp = self.client.get('/dataset_select')
# test response
assert resp.mimetype == 'application/json'
data = json.loads(resp.get_data())
assert isinstance(data, list)
assert len(data) == 2
assert isinstance(data[0], dict)
assert data[0]['code'] == md.d1_code or data[1]['code'] == md.d1_code
assert data[0]['code'] == md.d2_code or data[1]['code'] == md.d2_code
assert len(data[0]['methods']) == 2 if data[0]['code'] == md.d1_code else len(data[0]['methods']) == 1
assert len(data[1]['methods']) == 2 if data[0]['code'] != md.d1_code else len(data[1]['methods']) == 1
assert bytes(md.d1_file_path, 'utf-8') not in resp.get_data()
assert bytes(md.d2_file_path, 'utf-8') not in resp.get_data()
def insert_tract_test_data(self):
s1 = Subject(subject_id=md.s1_subject_id,
gender=md.s1_gender,
age=md.s1_age,
handedness=md.s1_handedness,
edinburgh_handedness_raw=md.s1_edinburgh_handedness_raw,
ravens_iq_raw=md.s1_ravens_iq_raw,
dataset_code=md.s1_dataset_code,
file_path=md.s1_file_path,
mmse=md.s1_mmse)
db.session.add(s1)
s2 = Subject(subject_id=md.s2_subject_id,
gender=md.s2_gender,
age=md.s2_age,
handedness=md.s2_handedness,
edinburgh_handedness_raw=md.s2_edinburgh_handedness_raw,
ravens_iq_raw=md.s2_ravens_iq_raw,
dataset_code=md.s2_dataset_code,
file_path=md.s2_file_path,
mmse=md.s2_mmse)
db.session.add(s2)
s3 = Subject(subject_id=md.s3_subject_id,
gender=md.s3_gender,
age=md.s3_age,
handedness=md.s3_handedness,
edinburgh_handedness_raw=md.s3_edinburgh_handedness_raw,
ravens_iq_raw=md.s3_ravens_iq_raw,
dataset_code=md.s3_dataset_code,
file_path=md.s3_file_path,
mmse=md.s3_mmse)
db.session.add(s3)
s4 = Subject(subject_id=md.s4_subject_id,
gender=md.s4_gender,
age=md.s4_age,
handedness=md.s4_handedness,
edinburgh_handedness_raw=md.s4_edinburgh_handedness_raw,
ravens_iq_raw=md.s4_ravens_iq_raw,
dataset_code=md.s4_dataset_code,
file_path=md.s4_file_path,
mmse=md.s4_mmse)
db.session.add(s4)
d1 = Dataset(md.d1_code, md.d1_name, md.d1_file_path, md.d1_query_params)
db.session.add(d1)
t1 = Tract(md.t1_code, md.t1_name, md.t1_file_path, md.t1_description)
db.session.add(t1)
t2 = Tract(md.t2_code, md.t2_name, md.t2_file_path, md.t2_description)
db.session.add(t2)
db.session.commit()
def test_get_static_tract_info_no_subjects(self):
''' Test 404 returned when no subjects in query. '''
s2 = Subject(subject_id=md.s2_subject_id,
gender=md.s2_gender,
age=md.s2_age,
handedness=md.s2_handedness,
edinburgh_handedness_raw=md.s2_edinburgh_handedness_raw,
ravens_iq_raw=md.s2_ravens_iq_raw,
dataset_code=md.s2_dataset_code,
file_path=md.s2_file_path,
mmse=md.s2_mmse)
db.session.add(s2)
s4 = Subject(subject_id=md.s4_subject_id,
gender=md.s4_gender,
age=md.s4_age,
handedness=md.s4_handedness,
edinburgh_handedness_raw=md.s4_edinburgh_handedness_raw,
ravens_iq_raw=md.s4_ravens_iq_raw,
dataset_code=md.s4_dataset_code,
file_path=md.s4_file_path,
mmse=md.s4_mmse)
db.session.add(s4)
d1 = Dataset(md.d1_code, md.d1_name, md.d1_file_path, md.d1_query_params)
db.session.add(d1)
t1 = Tract(md.t1_code, md.t1_name, md.t1_file_path, md.t1_description)
db.session.add(t1)
t2 = Tract(md.t2_code, md.t2_name, md.t2_file_path, md.t2_description)
db.session.add(t2)
db.session.commit()
resp = self.client.get(f'/get_tract_info/{md.t1_code}?{md.brc_atlas_males_query}')
self.assert404(resp)
def test_get_tract_no_subjects(self):
''' Test behaviour when there are no subjects returned by the selected query. '''
s2 = Subject(subject_id=md.s2_subject_id,
gender=md.s2_gender,
age=md.s2_age,
handedness=md.s2_handedness,
edinburgh_handedness_raw=md.s2_edinburgh_handedness_raw,
ravens_iq_raw=md.s2_ravens_iq_raw,
dataset_code=md.s2_dataset_code,
file_path=md.s2_file_path,
mmse=md.s2_mmse)
db.session.add(s2)
s4 = Subject(subject_id=md.s4_subject_id,
gender=md.s4_gender,
age=md.s4_age,
handedness=md.s4_handedness,
edinburgh_handedness_raw=md.s4_edinburgh_handedness_raw,
ravens_iq_raw=md.s4_ravens_iq_raw,
dataset_code=md.s4_dataset_code,
file_path=md.s4_file_path,
mmse=md.s4_mmse)
db.session.add(s4)
d1 = Dataset(md.d1_code, md.d1_name, md.d1_file_path, md.d1_query_params)
db.session.add(d1)
t1 = Tract(md.t1_code, md.t1_name, md.t1_file_path, md.t1_description)
db.session.add(t1)
t2 = Tract(md.t2_code, md.t2_name, md.t2_file_path, md.t2_description)
db.session.add(t2)
db.session.commit()
resp = self.tract_test_response(md.t1_code, md.brc_atlas_males_query)
self.assert404(resp)
def modify_datasets():
# get auth header and split to get the token string
auth_header = request.headers.get('Authorization')
auth_token = auth_header.split(" ")[1] if auth_header else ''
if auth_token:
# if auth token sent, deocde to get user id
user_id = User.decode_auth_token(auth_token)
# get user from database
# is it necessary to check the user id exists in the database?
# or is it sufficient that the token could be decoded using our secret key?
# its useful to have the user name for logging purposes anyway
user = User.query.filter(User.user_id == user_id).first()
if user:
if request.method == 'GET':
try:
datasets = Dataset.query.all()
response_object = {
'message': 'Successfully retrieved dataset records',
'datasets': datasets
}
current_app.logger.info(f'User {user.user_name} retrieved all dataset records.')
return make_response(jsonify(response_object)), 200
except Exception as e:
current_app.logger.error(f'Error occurred while user "{user.user_name}" was attempting to get all dataset records.')
current_app.logger.error(e)
return 'An error occurred while getting datasets.', 500
elif request.method == 'POST':
form = request.form
try:
dataset = Dataset(form['code'], form['name'], form['filePath'], form['queryParams'])
db.session.add(dataset)
db.session.commit()
current_app.logger.info(f'User "{user.user_name}" inserted a new dataset with code "{dataset.code}"')
return 'New dataset successfully created.', 201
except Exception as e:
db.session.rollback()
current_app.logger.error(f'Error occurred while user "{user.user_name}" was attempting to insert dataset.')
current_app.logger.error(e)
return 'An error occurred while creating a dataset record.', 500
elif request.method == 'PUT':
form = request.form
try:
dataset = Dataset.query.filter(Dataset.code == form['code']).first()
if dataset:
dataset.name = form['name']
dataset.file_path = form['filePath']
dataset.query_params = form['queryParams']
db.session.commit()
current_app.logger.info(f'User {user.user_name} updated dataset {dataset.code}.')
return 'Dataset successfully updated.', 200
else:
raise Exception('Can\'t update dataset that doesn\'t exist.')
except Exception as e:
db.session.rollback()
current_app.logger.error(f'Error occurred while user {user.user_name} was attempting to update dataset {dataset}.')
current_app.logger.error(e)
return 'An error occurred while updating dataset.', 500
elif request.method == 'DELETE':
code = request.args['code']
if code:
try:
dataset = Dataset.query.filter(Dataset.code == code).first()
if dataset:
Dataset.query.filter(Dataset.code == code).delete()
db.session.commit()
else:
raise Exception(f'Cannot delete dataset with code "{code}" since a record doesn\'t exist.')
current_app.logger.info(f'User {user.user_name} deleted dataset {code}.')
return 'Dataset successfully deleted.', 200
except Exception as e:
db.session.rollback()
current_app.logger.error(f'Error occurred while user {user.user_name} was attempting to delete dataset with code {code}.')
current_app.logger.error(e)
return 'An error occurred while deleting dataset.', 500
else:
current_app.logger.warn('No code sent with dataset DELETE request')
return 'No dataset code was sent with DELETE request.', 400
else:
current_app.logger.warn(f'No user with id "{user_id}" found in database.')
return 'Invalid user id passed with authentication token', 401
else:
current_app.logger.warn('No authentication token sent with request to /datasets')
return 'No authentication token sent with request.', 401
def test_subject_id_dataset_file_path(self):
# insert 2 test datasets
dataset1 = Dataset(code=DatabaseUtilsTestCase.dataset1_code,
name=DatabaseUtilsTestCase.dataset1_name,
file_path=DatabaseUtilsTestCase.dataset1_file_path,
query_params=DatabaseUtilsTestCase.dataset1_query_params)
db.session.add(dataset1)
dataset2 = Dataset(code=DatabaseUtilsTestCase.dataset2_code,
name=DatabaseUtilsTestCase.dataset2_name,
file_path=DatabaseUtilsTestCase.dataset2_file_path,
query_params=DatabaseUtilsTestCase.dataset2_query_params)
db.session.add(dataset2)
# insert subjects
sbjct1 = Subject(subject_id=DatabaseUtilsTestCase.sbjct1_subject_id,
gender=DatabaseUtilsTestCase.sbjct1_gender,
age=DatabaseUtilsTestCase.sbjct1_age,
handedness=DatabaseUtilsTestCase.sbjct1_handedness,
edinburgh_handedness_raw=DatabaseUtilsTestCase.sbjct1_edinburgh_handedness_raw,
ravens_iq_raw=DatabaseUtilsTestCase.sbjct1_ravens_iq_raw,
dataset_code=DatabaseUtilsTestCase.sbjct1_dataset_code,
file_path=DatabaseUtilsTestCase.sbjct1_file_path,
mmse=DatabaseUtilsTestCase.sbjct1_mmse)
db.session.add(sbjct1)
sbjct2 = Subject(subject_id=DatabaseUtilsTestCase.sbjct2_subject_id,
gender=DatabaseUtilsTestCase.sbjct2_gender,
age=DatabaseUtilsTestCase.sbjct2_age,
handedness=DatabaseUtilsTestCase.sbjct2_handedness,
edinburgh_handedness_raw=DatabaseUtilsTestCase.sbjct2_edinburgh_handedness_raw,
ravens_iq_raw=DatabaseUtilsTestCase.sbjct2_ravens_iq_raw,
dataset_code=DatabaseUtilsTestCase.sbjct2_dataset_code,
file_path=DatabaseUtilsTestCase.sbjct2_file_path,
mmse=DatabaseUtilsTestCase.sbjct2_mmse)
db.session.add(sbjct2)
sbjct3 = Subject(subject_id=DatabaseUtilsTestCase.sbjct3_subject_id,
gender=DatabaseUtilsTestCase.sbjct3_gender,
age=DatabaseUtilsTestCase.sbjct3_age,
handedness=DatabaseUtilsTestCase.sbjct3_handedness,
edinburgh_handedness_raw=DatabaseUtilsTestCase.sbjct3_edinburgh_handedness_raw,
ravens_iq_raw=DatabaseUtilsTestCase.sbjct3_ravens_iq_raw,
dataset_code=DatabaseUtilsTestCase.sbjct3_dataset_code,
file_path=DatabaseUtilsTestCase.sbjct3_file_path,
mmse=DatabaseUtilsTestCase.sbjct3_mmse)
db.session.add(sbjct3)
sbjct4 = Subject(subject_id=DatabaseUtilsTestCase.sbjct4_subject_id,
gender=DatabaseUtilsTestCase.sbjct4_gender,
age=DatabaseUtilsTestCase.sbjct4_age,
handedness=DatabaseUtilsTestCase.sbjct4_handedness,
edinburgh_handedness_raw=DatabaseUtilsTestCase.sbjct4_edinburgh_handedness_raw,
ravens_iq_raw=DatabaseUtilsTestCase.sbjct4_ravens_iq_raw,
dataset_code=DatabaseUtilsTestCase.sbjct4_dataset_code,
file_path=DatabaseUtilsTestCase.sbjct4_file_path,
mmse=DatabaseUtilsTestCase.sbjct4_mmse)
db.session.add(sbjct4)
db.session.commit()
test_query = {
"TESTDATASET1": {
"method": "DTI",
"constraints": {
"handedness": {"type": "checkbox", "values": ["R","L"]}
}
},
"TESTDATASET2": {
"method": "DTI",
"constraints": {
"handedness": {"type": "checkbox", "values": ["R","L"]}
}
}
}
result = dbu.subject_id_dataset_file_path(test_query)
assert len(result) == 4
sorted_result = sorted(result, key=lambda subject: subject[0])
assert sorted_result[0][0] == DatabaseUtilsTestCase.sbjct1_subject_id
assert sorted_result[0][1] == DatabaseUtilsTestCase.dataset1_file_path
assert sorted_result[1][0] == DatabaseUtilsTestCase.sbjct2_subject_id
assert sorted_result[1][1] == DatabaseUtilsTestCase.dataset1_file_path
assert sorted_result[2][0] == DatabaseUtilsTestCase.sbjct3_subject_id
assert sorted_result[2][1] == DatabaseUtilsTestCase.dataset1_file_path
assert sorted_result[3][0] == DatabaseUtilsTestCase.sbjct4_subject_id
assert sorted_result[3][1] == DatabaseUtilsTestCase.dataset2_file_path
def test_get_tract_select_info(self):
# insert 2 test tracts
tract1 = Tract(code=DatabaseUtilsTestCase.tract1_code,
name=DatabaseUtilsTestCase.tract1_name,
file_path=DatabaseUtilsTestCase.tract1_file_path,
description=DatabaseUtilsTestCase.tract1_description)
db.session.add(tract1)
tract2 = Tract(code=DatabaseUtilsTestCase.tract2_code,
name=DatabaseUtilsTestCase.tract2_name,
file_path=DatabaseUtilsTestCase.tract2_file_path,
description=DatabaseUtilsTestCase.tract2_description)
db.session.add(tract2)
# insert 2 test datasets
dataset1 = Dataset(code=DatabaseUtilsTestCase.dataset1_code,
name=DatabaseUtilsTestCase.dataset1_name,
file_path=DatabaseUtilsTestCase.dataset1_file_path,
query_params=DatabaseUtilsTestCase.dataset1_query_params)
db.session.add(dataset1)
dataset2 = Dataset(code=DatabaseUtilsTestCase.dataset2_code,
name=DatabaseUtilsTestCase.dataset2_name,
file_path=DatabaseUtilsTestCase.dataset2_file_path,
query_params=DatabaseUtilsTestCase.dataset2_query_params)
db.session.add(dataset2)
# insert records linking 2 of the tracts to the datasets into dataset_tracts
datrac1 = DatasetTracts(dataset_code=DatabaseUtilsTestCase.dataset1_code,
tract_code=DatabaseUtilsTestCase.tract1_code,
method_code=DatabaseUtilsTestCase.method1_code)
db.session.add(datrac1)
datrac2 = DatasetTracts(dataset_code=DatabaseUtilsTestCase.dataset1_code,
tract_code=DatabaseUtilsTestCase.tract2_code,
method_code=DatabaseUtilsTestCase.method1_code)
db.session.add(datrac2)
datrac3 = DatasetTracts(dataset_code=DatabaseUtilsTestCase.dataset2_code,
tract_code=DatabaseUtilsTestCase.tract1_code,
method_code=DatabaseUtilsTestCase.method1_code)
db.session.add(datrac3)
db.session.commit()
# test no ignored tracts
result, ignored_tracts = dbu.get_tract_select_info()
assert len(result.keys()) == 2
assert len(ignored_tracts) == 0
assert DatabaseUtilsTestCase.tract1_code in result.keys()
assert DatabaseUtilsTestCase.tract2_code in result.keys()
tract1_info = result[DatabaseUtilsTestCase.tract1_code]
tract2_info = result[DatabaseUtilsTestCase.tract2_code]
assert tract1_info['name'] == DatabaseUtilsTestCase.tract1_name
assert tract1_info['description'] == DatabaseUtilsTestCase.tract1_description
assert len(tract1_info['datasets']) == 2
assert tract2_info['name'] == DatabaseUtilsTestCase.tract2_name
assert tract2_info['description'] == DatabaseUtilsTestCase.tract2_description
assert len(tract2_info['datasets']) == 1
# test ignored tracts
tract3 = Tract(code=DatabaseUtilsTestCase.tract3_code,
name=DatabaseUtilsTestCase.tract3_name,
file_path=DatabaseUtilsTestCase.tract3_file_path,
description=DatabaseUtilsTestCase.tract3_description)
db.session.add(tract3)
db.session.commit()
result, ignored_tracts = dbu.get_tract_select_info()
assert len(result.keys()) == 2
assert len(ignored_tracts) == 1
assert ignored_tracts[0] == DatabaseUtilsTestCase.tract3_code
def test_get_dataset_select_info(self):
# insert 2 test datasets
dataset1 = Dataset(code=DatabaseUtilsTestCase.dataset1_code,
name=DatabaseUtilsTestCase.dataset1_name,
file_path=DatabaseUtilsTestCase.dataset1_file_path,
query_params=DatabaseUtilsTestCase.dataset1_query_params)
db.session.add(dataset1)
dataset2 = Dataset(code=DatabaseUtilsTestCase.dataset2_code,
name=DatabaseUtilsTestCase.dataset2_name,
file_path=DatabaseUtilsTestCase.dataset2_file_path,
query_params=DatabaseUtilsTestCase.dataset2_query_params)
db.session.add(dataset2)
method1 = Method(code=DatabaseUtilsTestCase.method1_code,
name=DatabaseUtilsTestCase.method1_name,
description=DatabaseUtilsTestCase.method1_description)
db.session.add(method1)
method2 = Method(code=DatabaseUtilsTestCase.method2_code,
name=DatabaseUtilsTestCase.method2_name,
description=DatabaseUtilsTestCase.method2_description)
db.session.add(method2)
dataset_tracts1 = DatasetTracts(dataset_code=DatabaseUtilsTestCase.dataset1_code,
method_code=DatabaseUtilsTestCase.method1_code,
tract_code=DatabaseUtilsTestCase.tract1_code)
db.session.add(dataset_tracts1)
dataset_tracts2 = DatasetTracts(dataset_code=DatabaseUtilsTestCase.dataset1_code,
method_code=DatabaseUtilsTestCase.method2_code,
tract_code=DatabaseUtilsTestCase.tract1_code)
db.session.add(dataset_tracts2)
dataset_tracts3 = DatasetTracts(dataset_code=DatabaseUtilsTestCase.dataset2_code,
method_code=DatabaseUtilsTestCase.method1_code,
tract_code=DatabaseUtilsTestCase.tract1_code)
db.session.add(dataset_tracts3)
dataset_tracts4 = DatasetTracts(dataset_code=DatabaseUtilsTestCase.dataset2_code,
method_code=DatabaseUtilsTestCase.method1_code,
tract_code=DatabaseUtilsTestCase.tract2_code)
db.session.add(dataset_tracts4)
db.session.commit()
dataset_codes = set([DatabaseUtilsTestCase.dataset1_code, DatabaseUtilsTestCase.dataset2_code])
method_codes = set([DatabaseUtilsTestCase.method1_code, DatabaseUtilsTestCase.method2_code])
datasets = dbu.get_dataset_select_info()
assert len(datasets) == 2
assert datasets[0]['code'] in dataset_codes
assert datasets[1]['code'] in dataset_codes.symmetric_difference([datasets[0]['code']])
for dataset in datasets:
if dataset['code'] == DatabaseUtilsTestCase.dataset1_code:
assert len(dataset['methods']) == 2
assert dataset['methods'][0] in method_codes
assert dataset['methods'][1] in method_codes.symmetric_difference([dataset['methods'][0]])
else:
assert len(dataset['methods']) == 1
assert dataset['methods'][0] == DatabaseUtilsTestCase.method1_code
def test_generate_mean_maps(self):
s1 = Subject(subject_id=md.s1_subject_id,
gender=md.s1_gender,
age=md.s1_age,
handedness=md.s1_handedness,
edinburgh_handedness_raw=md.s1_edinburgh_handedness_raw,
ravens_iq_raw=md.s1_ravens_iq_raw,
dataset_code=md.s1_dataset_code,
file_path=md.s1_file_path,
mmse=md.s1_mmse)
db.session.add(s1)
s2 = Subject(subject_id=md.s2_subject_id,
gender=md.s2_gender,
age=md.s2_age,
handedness=md.s2_handedness,
edinburgh_handedness_raw=md.s2_edinburgh_handedness_raw,
ravens_iq_raw=md.s2_ravens_iq_raw,
dataset_code=md.s2_dataset_code,
file_path=md.s2_file_path,
mmse=md.s2_mmse)
db.session.add(s2)
s3 = Subject(subject_id=md.s3_subject_id,
gender=md.s3_gender,
age=md.s3_age,
handedness=md.s3_handedness,
edinburgh_handedness_raw=md.s3_edinburgh_handedness_raw,
ravens_iq_raw=md.s3_ravens_iq_raw,
dataset_code=md.s3_dataset_code,
file_path=md.s3_file_path,
mmse=md.s3_mmse)
db.session.add(s3)
s4 = Subject(subject_id=md.s4_subject_id,
gender=md.s4_gender,
age=md.s4_age,
handedness=md.s4_handedness,
edinburgh_handedness_raw=md.s4_edinburgh_handedness_raw,
ravens_iq_raw=md.s4_ravens_iq_raw,
dataset_code=md.s4_dataset_code,
file_path=md.s4_file_path,
mmse=md.s4_mmse)
db.session.add(s4)
d1 = Dataset(code=md.d1_code, name=md.d1_name, file_path=md.d1_file_path, query_params=md.d1_query_params)
db.session.add(d1)
d2 = Dataset(code=md.d2_code, name=md.d2_name, file_path=md.d2_file_path, query_params=md.d1_query_params)
db.session.add(d2)
db.session.commit()
self.saved_file_path = ''
self.saved_img = None
def nib_save_patch(img, file_path):
self.saved_file_path = file_path
self.saved_img = img
data = img.get_data()
assert np.all(data == 1.)
def nib_load_patch(file_path):
if du.TEMPLATE_FILE_NAME in file_path:
return md.template_nifti
elif md.s1_subject_id in file_path:
return md.s1_MD if 'MD' in file_path else md.s1_FA
elif md.s3_subject_id in file_path:
return md.s3_MD if 'MD' in file_path else md.s3_FA
else:
print('Unexpected file path passed to nib_load_path in test_views.test_generate_maps')
print(file_path)
return
# assert the cache is empty for query string before response
assert not current_app.cache.get(md.brc_atlas_males_query)
# first request
with monkey_patch(du.nib, 'save', nib_save_patch):
with monkey_patch(du.nib, 'load', nib_load_patch):
resp = self.client.get(f'/generate_mean_maps?{md.brc_atlas_males_query}')
self.assertStatus(resp, 204)
assert current_app.cache.get(md.brc_atlas_males_query) # check data has been cached