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)