def test_backend_remove_patient(gpx4_patients, database):
""" Test adding 2 test patients and then removing them using label or ID """
# test conversion to format required for the database:
test_mme_patients = [ mme_patient(json_patient=patient) for patient in gpx4_patients]
# make sure 2 json patient are correctly parsed
assert len(test_mme_patients) == 2
# insert the 2 patients into the database
inserted_ids = [ backend_add_patient(mongo_db=database, patient=mme_patient, match_external=False) for mme_patient in test_mme_patients ]
assert len(inserted_ids) == 2
# make sure that inserted patients contain computed phenotypes from Monarch
a_patient = database['patients'].find_one()
assert a_patient
# test removing a patient by ID:
remove_query = {'_id' : 'P0001058'}
deleted = delete_by_query(remove_query, database, 'patients')
db_patients = database['patients'].find()
assert db_patients.count() == 1
# test removing a patient by label:
remove_query = {'label' : '350_2-test'}
deleted = delete_by_query(remove_query, database, 'patients')
db_patients = database['patients'].find()
assert db_patients.count() == 0
def add():
"""Add patient to database"""
formatted_patient = controllers.check_request(current_app.db, request)
if isinstance(formatted_patient, int): # some error must have occurred during validation
return controllers.bad_request(formatted_patient)
match_external = False
if controllers.get_nodes(database=current_app.db):
match_external = True
# else import patient to database
modified, inserted, matching_obj= backend_add_patient(mongo_db=current_app.db, patient=formatted_patient,
match_external=match_external)
message = {}
if modified:
message['message'] = 'Patient was successfully updated.'
elif inserted:
message['message'] = 'Patient was successfully inserted into database.'
else:
message['message'] = 'Database content is unchanged.'
# if patient is matching any other patient on other nodes
# and match notifications are on
if current_app.config.get('MAIL_SERVER') and matching_obj and len(matching_obj.get('results')):
# send an email to patient's contact:
notify_match_external(match_obj=matching_obj, admin_email=current_app.config.get('MAIL_USERNAME'),
mail=current_app.mail, notify_complete=current_app.config.get('NOTIFY_COMPLETE'))
resp = jsonify(message)
resp.status_code = 200
return resp
def test_external_matching(database, test_node, gpx4_patients, monkeypatch):
"""Testing the function that trigger patient matching across connected nodes"""
patient = gpx4_patients[0]
# insert test node object in database
database['nodes'].insert_one(test_node)
# insert patient object in database
inserted_ids = backend_add_patient(mongo_db=database,
patient=patient,
match_external=False)
assert inserted_ids
class MockResponse(object):
def __init__(self):
self.status_code = 200
def json(self):
resp = {
"disclaimer": "This is a test disclaimer",
"results": gpx4_patients
}
return resp
def mock_response(*args, **kwargs):
return MockResponse()
monkeypatch.setattr(requests, 'request', mock_response)
ext_m_result = external_matcher(database, patient, test_node['_id'])
assert isinstance(ext_m_result, dict)
assert ext_m_result['data']['patient']['id'] == patient['id']
assert ext_m_result['has_matches'] == True
assert ext_m_result['match_type'] == 'external'
def test_delete_patient(mock_app, database, gpx4_patients, test_client,
match_objs):
"""Test deleting a patient from database by sending a DELETE request"""
# load 2 patients from demo data in mock database
assert len(gpx4_patients) == 2
inserted_ids = []
for pat in gpx4_patients:
# convert patient in mme patient type (convert also gene to ensembl)
mme_pat = mme_patient(pat, True)
inserted_ids.append(backend_add_patient(database, mme_pat))
assert len(inserted_ids) == 2
# 50 cases present on patients collection
delete_id = "P0001058"
# try to delete patient without auth token:
response = mock_app.test_client().delete("".join(
["patient/delete/", delete_id]))
assert response.status_code == 401
# Add a valid client node
ok_token = test_client["auth_token"]
add_node(mongo_db=mock_app.db, obj=test_client, is_client=True)
# Send delete request providing a valid token but a non valid id
response = mock_app.test_client().delete("".join(
["patient/delete/", "not_a_valid_ID"]),
headers=auth_headers(ok_token))
assert response.status_code == 200
data = json.loads(response.data)
# but server returns error
assert (
data["message"] ==
"ERROR. Could not delete a patient with ID not_a_valid_ID from database"
)
assert database["matches"].find_one() is None # no matches in database
# insert into database some mock matching objects
database["matches"].insert_many(match_objs)
# patient "delete_id" should have two associated matches in database
results = database["matches"].find({"data.patient.id": delete_id})
assert len(list(results)) == 2
# Send valid patient ID and valid token
response = mock_app.test_client().delete("".join(
["patient/delete/", delete_id]),
headers=auth_headers(ok_token))
assert response.status_code == 200
# make sure that the patient was removed from database
results = database["patients"].find()
assert len(list(results)) == 1
# make sure that patient matches are also gone
results = database["matches"].find()
assert len(list(results)) == 1
def test_match_hgnc_symbol_patient(mock_app, gpx4_patients, test_client,
database):
"""Testing matching patient with gene symbl against patientMatcher database (internal matching)"""
# add an authorized client to database
ok_token = test_client["auth_token"]
add_node(mongo_db=mock_app.db, obj=test_client, is_client=True)
query_patient = {"patient": gpx4_patients[0]}
assert query_patient["patient"]["genomicFeatures"][0]["gene"][
"id"] == "GPX4"
# load 2 test patient in mock database
assert len(gpx4_patients) == 2
inserted_ids = []
for pat in gpx4_patients:
# convert patient in mme patient type (convert also gene to ensembl)
mme_pat = mme_patient(pat, True)
inserted_ids.append(backend_add_patient(database, mme_pat))
assert len(inserted_ids) == 2
# test the API response validator with non valid patient data:
malformed_match_results = {"results": "fakey_results"}
assert validate_response(malformed_match_results) == 422
# make sure that there are no patient matches in the 'matches collection'
assert database["matches"].find_one() is None
# send a POST request to match patient with patients in database
response = mock_app.test_client().post("/match",
data=json.dumps(query_patient),
headers=auth_headers(ok_token))
assert response.status_code == 200 # POST request should be successful
data = json.loads(response.data)
# data should contain results and the max number of results is as defined in the config file
assert len(data["results"]) == 2
assert type(data["results"]) == list # which is a list
assert "patient" in data["results"][0] # of patients
assert "score" in data["results"][0] # with matching scores
assert "contact" in data["results"][0][
"patient"] # contact info should be available as well
# make sure that there are match object is created in db for this internal matching
match = database["matches"].find_one()
for res in match["results"]:
for pat in res["patients"]:
assert pat["patient"][
"contact"] # each result should have a contact person
assert pat["score"]["patient"] > 0
def test_match_entrez_patient(mock_app, test_client, gpx4_patients, database):
"""Test matching patient with ensembl gene against patientMatcher database (internal matching)"""
# add an authorized client to database
ok_token = test_client['auth_token']
add_node(mongo_db=mock_app.db, obj=test_client, is_client=True)
query_patient = gpx4_patients[0]
query_patient = {'patient': gpx4_patients[0]}
for feat in query_patient['patient']['genomicFeatures']:
feat['gene']['id'] == "2879" # entrez id for GPX4
# load 2 test patient in mock database
assert len(gpx4_patients) == 2
inserted_ids = []
for pat in gpx4_patients:
# convert patient in mme patient type (convert also gene to ensembl)
mme_pat = mme_patient(pat, True)
inserted_ids.append(backend_add_patient(database, mme_pat))
assert len(inserted_ids) == 2
# make sure that there are no patient matches in the 'matches collection'
assert database['matches'].find().count() == 0
# send a POST request to match patient with patients in database
response = mock_app.test_client().post('/match',
data=json.dumps(query_patient),
headers=auth_headers(ok_token))
assert response.status_code == 200 # POST request should be successful
data = json.loads(response.data)
# data should contain results and the max number of results is as defined in the config file
assert len(data['results']) == 2
assert type(data['results']) == list # which is a list
assert 'patient' in data['results'][0] # of patients
assert 'score' in data['results'][0] # with matching scores
assert 'contact' in data['results'][0][
'patient'] # contact info should be available as well
# make sure that a match object is created in db for this internal matching
match = database['matches'].find_one()
for res in match['results']:
for pat in res['patients']:
assert pat['patient'][
'contact'] # each result should have a contact person
assert pat['score']['patient'] > 0
# and query patient should have hgnc gene symbol saved as non-standard _geneName field
assert match['data']['patient']['genomicFeatures'][0]['gene'][
'_geneName'] == 'GPX4'
