def update(self, data):
"""Update user."""
url = '{0}/users/contact_preference'.format(self.url)
headers = {
"Content-Type": "application/json",
"Accept": "application/json"
}
try:
response = g.requests.patch(url,
json=data,
headers=headers,
timeout=self.timeout)
response.raise_for_status()
except requests.exceptions.HTTPError as error:
current_app.logger.error(
'Encountered non 2xx http code from ulapd_api for user activation'
)
raise ApplicationError(*errors.get(
"verification_api", "ULAPD_API_HTTP_ERROR", filler=str(error)))
except requests.exceptions.ConnectionError as error:
current_app.logger.error(
'Encountered an error connecting to ulapd_api for user activation'
)
raise ApplicationError(*errors.get(
"verification_api", "ULAPD_API_CONN_ERROR", filler=str(error)))
except requests.exceptions.Timeout as error:
current_app.logger.error(
'Encountered a timeout when writing to ulapd_api for user activation'
)
raise ApplicationError(*errors.get(
"verification_api", "ULAPD_API_TIMEOUT", filler=str(error)))
else:
app.logger.info("Update user {}".format(data['user_id']))
return {'message': 'user updated'}
def get_dataset_activity(self, user_id):
"""Get a users licence agreements and download history"""
url = '{0}/users/dataset-activity/{1}'.format(self.url, user_id)
headers = {
"Content-Type": "application/json",
"Accept": "application/json"
}
try:
response = g.requests.get(url,
headers=headers,
timeout=self.timeout)
response.raise_for_status()
except requests.exceptions.HTTPError as error:
current_app.logger.error(
'Encountered non 2xx http code from ulapd_api getting users dataset activity'
)
raise ApplicationError(*errors.get(
"verification_api", "ULAPD_API_HTTP_ERROR", filler=str(error)))
except requests.exceptions.ConnectionError as error:
current_app.logger.error(
'Encountered an error connecting to ulapd_api getting users dataset activity'
)
raise ApplicationError(*errors.get(
"verification_api", "ULAPD_API_CONN_ERROR", filler=str(error)))
except requests.exceptions.Timeout as error:
current_app.logger.error(
'Encountered a timeout with ulapd_api getting users dataset activity'
)
raise ApplicationError(*errors.get(
"verification_api", "ULAPD_API_TIMEOUT", filler=str(error)))
else:
app.logger.info("Retrieved details of the users dataset activity")
return response.json()
def update_dataset_access(self, data):
"""Update dataset access for user (add/remove licences to ulapd database LDAP roles)"""
url = '{0}/users/licence'.format(self.url)
headers = {
"Content-Type": "application/json",
"Accept": "application/json"
}
try:
response = g.requests.post(url,
json=data,
headers=headers,
timeout=self.timeout)
response.raise_for_status()
except requests.exceptions.HTTPError as error:
current_app.logger.error(
'Encountered non 2xx http code from ulapd_api while updating dataset access'
)
raise ApplicationError(*errors.get(
"verification_api", "ULAPD_API_HTTP_ERROR", filler=str(error)))
except requests.exceptions.ConnectionError as error:
current_app.logger.error(
'Encountered an error connecting to ulapd_api while updating dataset access'
)
raise ApplicationError(*errors.get(
"verification_api", "ULAPD_API_CONN_ERROR", filler=str(error)))
except requests.exceptions.Timeout as error:
current_app.logger.error(
'Encountered a timeout with ulapd_api getting while updating dataset access'
)
raise ApplicationError(*errors.get(
"verification_api", "ULAPD_API_TIMEOUT", filler=str(error)))
else:
app.logger.info("Updated user dataset access")
return response.json()
def get(self, ldap_id):
url = '{0}/{1}/users?id={2}'.format(self.url, self.version, ldap_id)
headers = {
"Accept": "application/json",
'Authorization': 'Bearer ' + self.key
}
try:
response = g.requests.get(url,
headers=headers,
timeout=self.timeout)
response.raise_for_status()
except requests.exceptions.HTTPError as error:
current_app.logger.error(
'Encountered non 2xx http code from account_api for retrieving user details'
)
raise ApplicationError(*errors.get("verification_api",
"ACCOUNT_API_HTTP_ERROR",
filler=str(error)))
except requests.exceptions.ConnectionError as error:
current_app.logger.error(
'Encountered an error connecting to account_api for retrieving user details'
)
raise ApplicationError(*errors.get("verification_api",
"ACCOUNT_API_CONN_ERROR",
filler=str(error)))
except requests.exceptions.Timeout as error:
current_app.logger.error(
'Encountered a timeout when writing to account_api for retrieving user details'
)
raise ApplicationError(*errors.get(
"verification_api", "ACCOUNT_API_TIMEOUT", filler=str(error)))
else:
return response.json()
def get_dataset_list_details(self):
"""Get a detailed list of datasets in the service"""
url = '{}/datasets?simple=true'.format(self.url)
headers = {
"Content-Type": "application/json",
"Accept": "application/json"
}
try:
response = g.requests.get(url,
headers=headers,
timeout=self.timeout)
response.raise_for_status()
except requests.exceptions.HTTPError as error:
current_app.logger.error(
'Encountered non 2xx http code from ulapd_api when retrieving list of datasets'
)
raise ApplicationError(*errors.get(
"verification_api", "ULAPD_API_HTTP_ERROR", filler=str(error)))
except requests.exceptions.ConnectionError as error:
current_app.logger.error(
'Encountered an error connecting to ulapd_api when retrieving list of datasets'
)
raise ApplicationError(*errors.get(
"verification_api", "ULAPD_API_CONN_ERROR", filler=str(error)))
except requests.exceptions.Timeout as error:
current_app.logger.error(
'Encountered a timeout with ulapd_api when retrieving list of datasets'
)
raise ApplicationError(*errors.get(
"verification_api", "ULAPD_API_TIMEOUT", filler=str(error)))
else:
app.logger.info(
"Retrieved detailed list of datasets in the service")
return response.json()
def get_current_timestamp():
try:
conn = psycopg2.connect(current_app.config['SQLALCHEMY_DATABASE_URI'])
cur = conn.cursor()
cur.execute("SELECT CURRENT_TIMESTAMP;")
result = cur.fetchone()
cur.close()
conn.close()
return result[0]
except psycopg2.DataError as e:
raise ApplicationError('Input data error: ' + str(e),
'DB',
http_code=400)
except (psycopg2.OperationalError, psycopg2.ProgrammingError) as e:
raise ApplicationError('Database error: ' + str(e),
'DB',
http_code=400)
def test_insert_case_error(self, mock_case, *_):
error = ('verification_api', 'VERIFICATION_ERROR')
mock_case.side_effect = ApplicationError(
*errors.get(*error, filler='TEST ERR'))
with self.assertRaises(ApplicationError) as context:
service.insert_case({'foo': 'bar'})
self.assertEqual(context.exception.message,
errors.get_message(*error, filler='TEST ERR'))
self.assertEqual(context.exception.code, errors.get_code(*error))
def decline(self, ldap_id, decline_reason, decline_advice, user_id):
"""Decline user."""
url = '{0}/{1}/users/decline'.format(self.url, self.version)
headers = {
"Content-Type": "application/json",
"Accept": "application/json",
'Authorization': 'Bearer ' + self.key
}
reason = {
'ldap_id': ldap_id,
'reason': decline_reason,
'advice': decline_advice,
'user_id': user_id
}
try:
response = g.requests.post(url,
data=json.dumps(reason),
headers=headers,
timeout=self.timeout)
response.raise_for_status()
except requests.exceptions.HTTPError as error:
current_app.logger.error(
'Encountered non 2xx http code from account_api for declining user'
)
raise ApplicationError(*errors.get("verification_api",
"ACCOUNT_API_HTTP_ERROR",
filler=str(error)))
except requests.exceptions.ConnectionError as error:
current_app.logger.error(
'Encountered an error connecting to account_api for declining user'
)
raise ApplicationError(*errors.get("verification_api",
"ACCOUNT_API_CONN_ERROR",
filler=str(error)))
except requests.exceptions.Timeout as error:
current_app.logger.error(
'Encountered a timeout when writing to account_api for declining user'
)
raise ApplicationError(*errors.get(
"verification_api", "ACCOUNT_API_TIMEOUT", filler=str(error)))
else:
app.logger.info("Declined user {}".format(ldap_id))
return {'message': 'declined'}
def close(self, ldap_id, user_id, requester):
"""Close users account"""
url = '{0}/{1}/users/close'.format(self.url, self.version)
headers = {
"Content-Type": "application/json",
"Accept": "application/json",
'Authorization': 'Bearer ' + self.key
}
closure_data = {
'ldap_id': ldap_id,
'user_id': user_id,
'requester': requester
}
try:
response = g.requests.post(url,
data=json.dumps(closure_data),
headers=headers,
timeout=self.timeout)
response.raise_for_status()
except requests.exceptions.HTTPError as error:
current_app.logger.error(
'Encountered non 2xx http code from account_api for closing account'
)
raise ApplicationError(*errors.get("verification_api",
"ACCOUNT_API_HTTP_ERROR",
filler=str(error)))
except requests.exceptions.ConnectionError as error:
current_app.logger.error(
'Encountered an error connecting to account_api for closing account'
)
raise ApplicationError(*errors.get("verification_api",
"ACCOUNT_API_CONN_ERROR",
filler=str(error)))
except requests.exceptions.Timeout as error:
current_app.logger.error(
'Encountered a timeout when writing to account_api for closing account'
)
raise ApplicationError(*errors.get(
"verification_api", "ACCOUNT_API_TIMEOUT", filler=str(error)))
else:
app.logger.info("closed account for user {}".format(ldap_id))
return {'message': 'closed'}
def test_decline_reasons_error(self, mock_extract, *_):
error = ('verification_api', 'VERIFICATION_ERROR')
mock_extract.side_effect = ApplicationError(
*errors.get(*error, filler='TEST ERR'))
with self.assertRaises(ApplicationError) as context:
service.get_decline_reasons()
self.assertEqual(context.exception.message,
errors.get_message(*error, filler='TEST ERR'))
self.assertEqual(context.exception.code, errors.get_code(*error))
def test_get_dataset_list_details_error(self, mock_service, *_):
mock_service.get_dataset_list_details.side_effect = ApplicationError(
*errors.get(*self.test_error))
response = self.app.get('/v1/dataset-list-details',
headers=self.headers)
expected_err = 'Failed to get detailed dataset list - {}'.format(
errors.get_message(*self.test_error))
self.assertEqual(response.get_json()['error'], expected_err)
self.assertEqual(response.status_code, 500)
def test_get_worklist_error(self, mock_service, *_):
mock_service.get_pending.side_effect = ApplicationError(*errors.get(
*self.test_error))
expected_err_msg = errors.get_message(*self.test_error)
response = self.app.get('/v1/worklist', headers=self.headers)
self.assertEqual(500, response.status_code)
response_body = response.get_json()
self.assertEqual("Failed to retrieve worklist - " + expected_err_msg,
response_body['error'])
def test_decline_reason_error(self, mock_service, *_):
mock_service.get_decline_reasons.side_effect = ApplicationError(
*errors.get(*self.test_error))
expected_err_msg = errors.get_message(*self.test_error)
response = self.app.get('/v1/decline-reasons', headers=self.headers)
self.assertEqual(500, response.status_code)
response_body = response.get_json()
self.assertEqual("Failed to get decline reasons - " + expected_err_msg,
response_body['error'])
def test_insert_metric_event_app_error(self, mock_create_payload, mock_app,
*_):
error = ApplicationError(
*errors.get("verification_api", "METRIC_API_HTTP_ERROR"))
mock_create_payload.side_effect = error
insert_metric_event('dst_action_approved', self.payload)
error_msg = 'Verification-api failed calling Metric API with error: {}'.format(
str(error))
mock_app.logger.error.assert_called_with(error_msg)
def test_unlock_error(self, mock_service, *_):
mock_service.manage_case_lock.side_effect = ApplicationError(
*errors.get(*self.test_error))
response = self.app.post('/v1/case/1/unlock',
json={},
headers=self.headers)
response_body = response.get_json()
expected_error_msg = errors.get_message(*self.test_error)
self.assertEqual(response.status_code, 500)
self.assertEqual(response_body['error'], expected_error_msg)
def test_dps_action_error(self, mock_account, mock_case, *_):
error = ('verification_api', 'VERIFICATION_ERROR')
mock_account.side_effect = ApplicationError(
*errors.get(*error, filler='TEST ERROR'))
mock_case.get_case_by_id.return_value = _generate_test_profile()
with self.assertRaises(ApplicationError) as context:
service.dps_action('Approve', '1', {'staff_id': 'LRTM101'})
expected_err = errors.get_message(*error, filler='TEST ERROR')
self.assertEqual(context.exception.message, expected_err)
self.assertEqual(context.exception.code, errors.get_code(*error))
def test_insert_metric_event_error(self, mock_create_payload,
mock_metric_api, *_):
mock_create_payload.return_value = {'foo': 'bar'}
error = ApplicationError(
*errors.get("verification_api", "METRIC_API_HTTP_ERROR"))
mock_metric_api.return_value.add_event.side_effect = error
with app.app_context() as ac:
metric_retry = current_app.config["METRIC_RETRY"]
ac.g.trace_id = None
insert_metric_event('dst_action_approved', self.payload)
self.assertEqual(mock_metric_api.return_value.add_event.call_count,
int(metric_retry))
def test_get_pending_error(self, mock_extract, mock_case, *_):
error = ('verification_api', 'VERIFICATION_ERROR')
mock_extract.side_effect = ApplicationError(
*errors.get(*error, filler='TEST ERR'))
with self.assertRaises(ApplicationError) as context:
mock_case.get_pending.return_value = _generate_test_profile()
service.get_pending()
self.assertEqual(context.exception.message,
errors.get_message(*error, filler='TEST ERR'))
self.assertEqual(context.exception.code, errors.get_code(*error))
def test_get_users_dataset_activity_error(self, mock_service, *_):
mock_service.get_dataset_activity.side_effect = ApplicationError(
*errors.get(*self.test_error))
expected_err_msg = errors.get_message(*self.test_error)
response = self.app.get('/v1/dataset-activity/1', headers=self.headers)
self.assertEqual(500, response.status_code)
response_body = response.get_json()
expected_err = 'Failed to get dataset activity - {}'.format(
expected_err_msg)
self.assertEqual(expected_err, response_body['error'])
def test_notepad_error(self, mock_service, *_):
mock_service.insert_note.side_effect = ApplicationError(*errors.get(
*self.test_error))
expected_err_msg = errors.get_message(*self.test_error)
json_body = {'note_text': 'A note', 'staff_id': 'AA123ZZ'}
response = self.app.post('/v1/case/1/note',
json=json_body,
headers=self.headers)
self.assertEqual(500, response.status_code)
response_body = response.get_json()
self.assertEqual("Failed to insert note - " + expected_err_msg,
response_body['error'])
def test_decline_error(self, mock_service, *_):
mock_service.dps_action.side_effect = ApplicationError(*errors.get(
*self.test_error))
expected_err_msg = errors.get_message(*self.test_error)
response = self.app.post('/v1/case/1/decline',
json=self.decline_body,
headers=self.headers)
self.assertEqual(500, response.status_code)
response_body = response.get_json()
self.assertEqual("Failed to decline case - " + expected_err_msg,
response_body['error'])
def get_user_dataset_access(case_id):
log.info('Getting dataset access for {}'.format(case_id))
case = Case.get_case_by_id(case_id)
if case is None:
raise ApplicationError(*errors.get('verification_api',
'CASE_NOT_FOUND',
filler=case_id),
http_code=404)
ulapd = UlapdAPI()
dataset_access_list = ulapd.get_user_dataset_access(case.user_id)
return dataset_access_list
def test_get_groups_error(self, mock_service, *_):
case_id = 999
mock_service.get_groups.side_effect = ApplicationError(*errors.get(
*self.test_error))
response = self.app.get('/v1/groups/{}'.format(case_id),
headers=self.headers)
expected_err = 'Failed to get groups - {}'.format(
errors.get_message(*self.test_error))
mock_service.get_groups.assert_called_once_with(str(case_id))
self.assertEqual(response.get_json()['error'], expected_err)
self.assertEqual(response.status_code, 500)
def approve(self, ldap_id):
"""Activate user."""
url = '{0}/{1}/users/{2}/activate'.format(self.url, self.version,
ldap_id)
headers = {
"Content-Type": "application/json",
"Accept": "application/json",
'Authorization': 'Bearer ' + self.key
}
try:
response = g.requests.post(url,
headers=headers,
timeout=self.timeout)
response.raise_for_status()
except requests.exceptions.HTTPError as error:
current_app.logger.error(
'Encountered non 2xx http code from account_api for user activation'
)
raise ApplicationError(*errors.get("verification_api",
"ACCOUNT_API_HTTP_ERROR",
filler=str(error)))
except requests.exceptions.ConnectionError as error:
current_app.logger.error(
'Encountered an error connecting to account_api for user activation'
)
raise ApplicationError(*errors.get("verification_api",
"ACCOUNT_API_CONN_ERROR",
filler=str(error)))
except requests.exceptions.Timeout as error:
current_app.logger.error(
'Encountered a timeout when writing to account_api for user activation'
)
raise ApplicationError(*errors.get(
"verification_api", "ACCOUNT_API_TIMEOUT", filler=str(error)))
else:
app.logger.info("Activated user {}".format(ldap_id))
return {'message': 'approved'}
def test_search_error(self, mock_service, *_):
mock_service.perform_search.side_effect = ApplicationError(*errors.get(
*self.test_error))
expected_err_msg = errors.get_message(*self.test_error)
json_body = {"first_name": "Andreea"}
response = self.app.post('/v1/search',
json=json_body,
headers=self.headers)
self.assertEqual(500, response.status_code)
response_body = response.get_json()
expected_err = 'Failed to perform search - {}'.format(expected_err_msg)
self.assertEqual(expected_err, response_body['error'])
def test_auto_close_error(self, mock_service, mock_audit, *_):
mock_service.auto_close.side_effect = ApplicationError(*errors.get(
*self.test_error))
expected_err_msg = errors.get_message(*self.test_error)
response = self.app.post('/v1/case/123456/auto_close',
json=self.close_body,
headers=self.headers)
self.assertEqual(500, response.status_code)
response_body = response.get_json()
expected_err = 'Failed to auto close account for ldap_id: 123456 - {}'.format(
expected_err_msg)
self.assertEqual(expected_err, response_body['error'])
def test_get_worklist_item_error(self, mock_service, *_):
mock_service.get_pending_by_id.side_effect = ApplicationError(
*errors.get(*self.test_error))
test_id = 1
response = self.app.get('/v1/case/{}'.format(test_id),
headers=self.headers)
response_body = response.get_json()
expected_err_msg = errors.get_message(*self.test_error)
expected_err_msg = "Failed to get case '{}' - {}".format(
test_id, expected_err_msg)
self.assertEqual(500, response.status_code)
self.assertEqual(expected_err_msg, response_body['error'])
def add_event(self, payload):
url = '{}/v1/metric'.format(self.url)
headers = {
"Content-Type": "application/json",
"Accept": "application/json"
}
try:
response = g.requests.post(url,
json=payload,
headers=headers,
timeout=self.timeout)
response.raise_for_status()
except requests.exceptions.HTTPError as error:
current_app.logger.error(
'Encountered non 2xx http code from dps_metric_api for adding event'
)
raise ApplicationError(*errors.get("verification_api",
"METRIC_API_HTTP_ERROR",
filler=str(error)))
except requests.exceptions.ConnectionError as error:
current_app.logger.error(
'Encountered an error connecting to dps_metric_api for adding event'
)
raise ApplicationError(*errors.get("verification_api",
"METRIC_API_CONN_ERROR",
filler=str(error)))
except requests.exceptions.Timeout as error:
current_app.logger.error(
'Encountered a timeout when writing to dps_metric_api for adding event'
)
raise ApplicationError(*errors.get(
"verification_api", "METRIC_API_TIMEOUT", filler=str(error)))
else:
app.logger.info("added event")
return {'message': 'event added'}
def run_and_handle(*args, **kwargs):
try:
return func(*args, **kwargs)
except SQLAlchemyError as error:
log.error(str(error))
error_code = 500 if is_get else 422
error_def = errors.get('verification_api',
'SQLALCHEMY_ERROR',
filler=str(error))
raise ApplicationError(*error_def, http_code=error_code)
except ApplicationError as error:
raise error
finally:
if not is_get:
db.session.rollback()
db.session.close()
def test_insert_note_error(self, mock_lock, *_):
test_error = ('verification_api', 'VERIFICATION_ERROR')
mock_lock.side_effect = ApplicationError(
*errors.get(*test_error, filler='TEST ERROR'))
with self.assertRaises(ApplicationError) as context:
service.insert_note('1', {
'staff_id': 'LRTM101',
'note_text': 'Test note'
})
expected_err_message = errors.get_message(*test_error,
filler='TEST ERROR')
expected_err_code = errors.get_code(*test_error)
self.assertEqual(context.exception.message, expected_err_message)
self.assertEqual(context.exception.code, expected_err_code)
