def test_set_creation_date(self):
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1)
tr_2 = t_db.get_transaction(t_id)
self.assertTrue(tr_2.creation_date)
def test_add_user_already_exists(self):
"""test that we can't add duplicate users by user name"""
engine = temp_db.get_temp_db()
t_db = TransactionDB(engine)
user_id = t_db.add_user('Pere', 'pwd')
self.assertTrue(user_id >= 0)
t_db.add_user('Pere', 'pwd')
def test_create_transaction_lm(self):
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
tr_1.last_message = json.dumps({
't_id': None,
'data': {
'dicom_info': {
't1': {
'header': {
'SeriesDescription': 'series_t1_1'
}
},
't2': {
'header': {
'SeriesDescription': 'series_t2_1'
}
}
}
}
})
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1)
tr_2 = t_db.get_transaction(t_id)
self.assertEqual(t_id, json.loads(tr_2.last_message)['t_id'])
def test_add_user_ok(self):
"""test that we can add User entity"""
engine = temp_db.get_temp_db()
t_db = TransactionDB(engine)
user_id = t_db.add_user('Pere', 'pwd')
user = t_db.session.query(User).get(user_id)
self.assertEqual('Pere', user.name)
self.assertTrue(user.hashed_password)
def test_user_preferences_invalid_keys(self):
"""test that upon providing an invalid preference key for the
preferences system, a TransactionDBException is thrown"""
engine = temp_db.get_temp_db()
t_db = TransactionDB(engine)
user_id_1 = t_db.add_user('Pere1', 'pwd')
t_db.set_user_preferences(user_id_1, {'foo': 'bar'})
def test_add_role_ok(self):
"""test that we can add a Role entity"""
engine = temp_db.get_temp_db()
t_db = TransactionDB(engine)
t_db.add_role('radiologist', 'whatever', 128)
role = t_db.session.query(Role).get('radiologist')
self.assertEqual('whatever', role.description)
self.assertEqual(128, role.permissions)
def test_user_preferences_invalid_user(self):
"""test that user_id is a foreign key in the relational model
of the user preferences, and as such will cause the db to fail
if we provide whatever as user_id"""
engine = temp_db.get_temp_db()
t_db = TransactionDB(engine)
t_db.set_user_preferences(100, {'report_language': 'en'})
def test_remove_user_ok(self):
"""test that we can remove an existing user from the database"""
engine = temp_db.get_temp_db()
t_db = TransactionDB(engine)
user_id = t_db.add_user('Pere', 'pwd')
user = t_db.session.query(User).get(user_id)
self.assertEqual('Pere', user.name)
t_db.remove_user(user_id)
user = t_db.session.query(User).get(user_id)
self.assertFalse(user)
def test_retry_logic_2(self):
"""test that our database retry logic works.
Raise exception randomly and perform the given task randomly,
such that retrying should eventually work"""
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1)
t = t_db.get_transaction(t_id)
self.assertEqual(0, t.patient_consent)
orig_f = t_db._get_transaction_or_raise_exception
should_fail_once = True
def mocked_f(t_id):
nonlocal should_fail_once
if should_fail_once:
should_fail_once = False
# Raising this exception means it should be retried
raise Sqlite3OperationalError
return orig_f(t_id)
t_db._get_transaction_or_raise_exception = mocked_f
try:
t_db.set_patient_consent(t_id)
except Exception:
pass
t = t_db.get_transaction(t_id)
self.assertEqual(1, t.patient_consent)
def test_read_transaction_from_dict(self):
d = {
'transaction_id': 1,
'name': 'John Doe',
'birth_date': '01/02/2020'
}
t = Transaction().read_dict(d)
engine = temp_db.get_temp_db()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(t)
t_from_db = t_db.get_transaction(t_id)
self.assertEqual(d['transaction_id'], t_from_db.transaction_id)
self.assertEqual(d['name'], t_from_db.name)
self.assertEqual(date(2020, 2, 1), t_from_db.birth_date)
def test_migrations(self):
temp_folder = tempfile.mkdtemp(
suffix='_test_migrations_transaction_db_')
temp_db_path = os.path.join(temp_folder, 't_v1.db')
shutil.copy('tests/fixtures/t_v1.db', temp_db_path)
engine = create_engine('sqlite:///' + temp_db_path)
# should execute all migrations code
t_db = TransactionDB(engine, create_db=True, db_file_path=temp_db_path)
self.assertTrue(os.path.exists(temp_db_path + '.v_1.bkp'))
# add a new transaction with the current model
t = Transaction()
t_db.create_transaction(t)
shutil.rmtree(temp_folder)
def test_migrate_institution(self):
engine = self._get_temp_db(2)
t_db = TransactionDB(engine)
last_message = {
'data': {
'dicom_info': {
't1': {
'header': {
'InstitutionName': 'MockInstitution'
}
}
}
}
}
tr_1 = Transaction()
tr_1.last_message = json.dumps(last_message)
t_id = t_db.create_transaction(tr_1)
# remove institution field
session = t_db.session
tr_2 = t_db.get_transaction(t_id)
tr_2.institution = ''
session.commit()
self.assertEqual('', t_db.get_transaction(t_id).institution)
# execute migrate python script
model = get_transaction_model(engine)
migrations.migrate_institution(session, model)
session.commit()
tr_2 = t_db.get_transaction(t_id)
self.assertEqual('MockInstitution', tr_2.institution)
t_db.close()
def test_revoke_user_role_ok(self):
"""test that we can revoke a role from a user"""
engine = temp_db.get_temp_db()
t_db = TransactionDB(engine)
user_id = t_db.add_user('Pere', 'pwd')
t_db.add_role('radiologist', 'whatever', 128)
t_db.add_user_role(user_id, 'radiologist')
self.assertTrue(self.__user_has_role(t_db, user_id, 'radiologist'))
t_db.revoke_user_role(user_id, 'radiologist')
self.assertFalse(self.__user_has_role(t_db, user_id, 'radiologist'))
def test_transaction_archived(self):
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1)
t = t_db.get_transaction(t_id)
self.assertEqual(t.archived, 0)
t_db.set_archived(t_id)
t = t_db.get_transaction(t_id)
self.assertEqual(t.archived, 1)
t_db.close()
def test_transaction_failed(self):
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1)
t_db.set_processing(t_id, '', '')
# to be called when a transaction fails
t_db.set_failed(t_id, 'because it failed')
t = t_db.get_transaction(t_id)
self.assertEqual(t.task_state, TaskState.failed)
self.assertTrue(t.end_date > t.start_date)
self.assertEqual(t.error, 'because it failed')
t_db.close()
def test_transaction_completed(self):
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1)
t_db.set_processing(t_id, '', '')
# to be called when a transaction completes
t_db.set_completed(t_id)
t = t_db.get_transaction(t_id)
self.assertEqual(t.task_state, TaskState.completed)
self.assertEqual(t.status, 'unseen')
self.assertTrue(t.end_date > t.start_date)
t_db.close()
def test_set_qa_score(self):
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1, qa_score='good')
t = t_db.get_transaction(t_id)
self.assertEqual('good', t.qa_score)
t_db.set_qa_score(t_id, 'rejected')
t = t_db.get_transaction(t_id)
self.assertEqual('rejected', t.qa_score)
t_db.close()
def test_set_billable(self):
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1)
t = t_db.get_transaction(t_id)
self.assertEqual(None, t.billable)
# set billable
t_db.set_billable(t_id, 'bill')
t = t_db.get_transaction(t_id)
self.assertEqual('bill', t.billable)
t_db.close()
def test_migrate_report_qa_2(self):
engine = self._get_temp_db(5)
t_db = TransactionDB(engine)
last_message = {
'data': {
'report_qa_score_outcomes': {
'mdbrain_nd': 'good',
'mdbrain_ms': 'acceptable'
}
}
}
tr_1 = Transaction()
tr_1.last_message = json.dumps(last_message)
t_id = t_db.create_transaction(tr_1)
tr_1 = t_db.get_transaction(t_id)
# by default TransactionsDB doesn't set this field
self.assertEqual(None, tr_1.qa_score)
# execute migrate python script
model = get_transaction_model(engine)
migrations.migrate_qa_scores(t_db.session, model)
t_db.session.commit()
tr_2 = t_db.get_transaction(t_id)
self.assertTrue('mdbrain_ms:acceptable' in tr_2.qa_score)
self.assertTrue('mdbrain_nd:good' in tr_2.qa_score)
t_db.close()
def test_migrate_analysis_type_2(self):
engine = self._get_temp_db(5)
t_db = TransactionDB(engine)
last_message = {
'data': {
'report_pdf_paths': {
'mdbrain_nd': 'path1',
'mdbrain_ms': 'path2'
}
}
}
tr_1 = Transaction()
tr_1.last_message = json.dumps(last_message)
t_id = t_db.create_transaction(tr_1)
tr_1 = t_db.get_transaction(t_id)
# by default TransactionsDB doesn't set this field
self.assertEqual(None, tr_1.analysis_type)
# execute migrate python script
model = get_transaction_model(engine)
migrations.migrate_analysis_types(t_db.session, model)
t_db.session.commit()
tr_2 = t_db.get_transaction(t_id)
self.assertTrue('mdbrain_ms' in tr_2.analysis_type)
self.assertTrue('mdbrain_nd' in tr_2.analysis_type)
t_db.close()
def test_migrate_study_date(self):
engine = self._get_temp_db(4)
t_db = TransactionDB(engine)
last_message = {
'data': {
'dicom_info': {
't1': {
'header': {
'StudyDate': '20190101'
}
}
}
}
}
tr_1 = Transaction()
tr_1.last_message = json.dumps(last_message)
t_id = t_db.create_transaction(tr_1)
tr_1 = t_db.get_transaction(t_id)
# by default TransactionsDB doesn't set this field
self.assertEqual(None, tr_1.study_date)
# execute migrate python script
model = get_transaction_model(engine)
migrations.migrate_study_date(t_db.session, model)
t_db.session.commit()
tr_2 = t_db.get_transaction(t_id)
self.assertEqual('20190101', tr_2.study_date)
t_db.close()
def test_set_priority(self):
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1)
t = t_db.get_transaction(t_id)
self.assertEqual(0, t.priority)
t_db.set_priority(t_id, 2)
t = t_db.get_transaction(t_id)
self.assertEqual(2, t.priority)
t_db.close()
def test_read_dict_dates(self):
# test that date and datetimes are parsed correctly
engine = temp_db.get_temp_db()
t_db = TransactionDB(engine)
datetime_vars = ['start_date', 'end_date', 'data_uploaded']
date_vars = ['birth_date']
t = Transaction()
for key in datetime_vars:
setattr(t, key, datetime(2020, 2, 1, 18, 30, 4))
for key in date_vars:
setattr(t, key, datetime(2020, 2, 1))
t_r = Transaction().read_dict(t.to_dict())
t_id = t_db.create_transaction(t_r)
t_r_from_db = t_db.get_transaction(t_id)
self.assertEqual(datetime(2020, 2, 1, 18, 30, 4),
t_r_from_db.start_date)
self.assertEqual(datetime(2020, 2, 1, 18, 30, 4), t_r_from_db.end_date)
self.assertEqual(date(2020, 2, 1), t_r_from_db.birth_date)
def test_revoke_user_role_didnt_exist(self):
"""test that an Exception is thrown if we want to revoke an
already revoked role from a user"""
engine = temp_db.get_temp_db()
t_db = TransactionDB(engine)
user_id = t_db.add_user('Pere', 'pwd')
t_db.add_role('radiologist', 'whatever')
t_db.revoke_user_role(user_id, 'radiologist')
def test_add_user_role_already_exists(self):
"""test that we can't assign twice the same role to a user"""
engine = temp_db.get_temp_db()
t_db = TransactionDB(engine)
user_id = t_db.add_user('Pere', 'pwd')
t_db.add_role('radiologist', 'whatever')
t_db.add_user_role(user_id, 'radiologist')
t_db.add_user_role(user_id, 'radiologist')
def test_set_status(self):
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1)
t_db.set_status(t_id, 'reviewed')
t = t_db.get_transaction(t_id)
self.assertEqual(t.status, 'reviewed')
t_db.close()
def test_change_last_message(self):
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1)
# update last_message field
t_db.set_last_message(t_id, 'last_message')
t = t_db.get_transaction(t_id)
self.assertEqual(t.last_message, 'last_message')
t_db.close()
def test_user_preferences(self):
"""test that the preferences saving and retrieving system works"""
engine = temp_db.get_temp_db()
t_db = TransactionDB(engine)
user_id_1 = t_db.add_user('Pere1', 'pwd')
user_id_2 = t_db.add_user('Pere2', 'pwd')
self.assertTrue(t_db.get_user_preferences(user_id_1) is None)
self.assertTrue(t_db.get_user_preferences(user_id_2) is None)
preferences = {'report_language': 'en'}
t_db.set_user_preferences(user_id_1, preferences)
preferences = {'report_language': 'de'}
t_db.set_user_preferences(user_id_2, preferences)
prefs = t_db.get_user_preferences(user_id_1)
self.assertEqual(user_id_1, prefs['user_id'])
self.assertEqual('en', prefs['report_language'])
prefs = t_db.get_user_preferences(user_id_2)
self.assertEqual(user_id_2, prefs['user_id'])
self.assertEqual('de', prefs['report_language'])
def test_change_processing_state(self):
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1)
# called when a transaction changes its processing state
t_db.set_processing(t_id, 'spm_volumetry', '{}', 10)
t = t_db.get_transaction(t_id)
self.assertEqual(t.processing_state, 'spm_volumetry')
self.assertEqual(t.task_state, TaskState.processing)
self.assertEqual(t.task_progress, 10)
t_db.close()
def test_transaction_cancelled(self):
engine = temp_db.get_temp_db()
tr_1 = self._get_test_transaction()
t_db = TransactionDB(engine)
t_id = t_db.create_transaction(tr_1)
# to be called when a transaction is skipped
t_db.set_cancelled(t_id, 'because it is cancelled')
t = t_db.get_transaction(t_id)
self.assertEqual(t.task_cancelled, 1)
self.assertEqual(t.error, 'because it is cancelled')
t_db.close()
