def test_has_drivers_licence_been_seized_method(prohibition_type,
test_condition, expected):
sample_data = load_json_into_dict(
'python/common/tests/sample_data/form/irp_form_submission.json')
response_from_api = load_json_into_dict(
'python/common/tests/sample_data/vips/vips_query_200.json')
response_from_api['data']['status'][
'driverLicenceSeizedYn'] = test_condition
response_from_api['data']['status']['noticeTypeCd'] = prohibition_type
vips_data = response_from_api['data']['status']
result, args = middleware.has_drivers_licence_been_seized(
message=sample_data, vips_data=vips_data)
assert result is expected
def main():
# logging.warning("inside main()")
input_dict = load_json_into_dict(ORIGINAL_JSON_FILE_PATH)
output = load_json_into_dict(ORIGINAL_JSON_FILE_PATH)
logging.warning(str(input_dict))
for template in ['12Hour']:
for field in input_dict[template]['fields'].keys():
logging.warning("template: {} field: {}".format(template, field))
starting_coordinate = input_dict[template]['fields'][field][
'start']
# print("OLD: {} - {}".format(template, str(starting_coordinate)))
converted_coordinate = convert_notice(starting_coordinate)
output[template]['fields'][field]['start'] = converted_coordinate
# print("NEW: {} - {}".format(template, str(converted_coordinate)))
print(json.dumps(output))
def get_sample_schedule_review_submission(prohibition_number: str, last_name: str, time_slot: str) -> dict:
message_dict = helper.load_json_into_dict('python/common/tests/sample_data/form/schedule_picker_submission.json')
event_type = message_dict['event_type']
message_dict[event_type]['form']['schedule-review-section']['prohibition_number'] = prohibition_number
message_dict[event_type]['form']['schedule-review-section']['last-name'] = last_name
message_dict[event_type]['form']['schedule-review-section']['timeslot-selected'] = time_slot
return message_dict
def validate_pay_bc_post_receipt(**args) -> tuple:
config = args.get('config')
payload = args.get('payload')
method_name = 'receipt'
schemas = helper.load_json_into_dict(config.SCHEMA_PATH +
config.SCHEMA_FILENAME)
# check that that the method_name has an associated validation schema
if method_name not in schemas:
logging.critical(
'{} does not have an associated validation schema'.format(
method_name))
# return the validation error message from the associated schema
schema = schemas[method_name]
logging.debug('schema: {}'.format(json.dumps(schema)))
logging.debug('payload: {}'.format(payload))
cerberus = Cerberus(schema['cerberus_rules'])
cerberus.allow_unknown = schema['allow_unknown']
if cerberus.validate(payload):
args['prohibition_number'] = payload['invoices'][0]["trx_number"]
logging.info('payload passed validation')
return True, args
else:
logging.warning('payload failed validation: {}'.format(
json.dumps(cerberus.errors)))
return False, args
def test_if_no_disclosure_add_back_to_hold_queue(monkeypatch):
message_dict = helper.load_json_into_dict(
'python/common/tests/sample_data/form/disclosure_payload.json')
message_dict['hold_until'] = (datetime.datetime.now() -
datetime.timedelta(hours=1)).isoformat()
tz = pytz.timezone('America/Vancouver')
review_start_date = vips.vips_datetime(
datetime.datetime.now(tz) - datetime.timedelta(days=1))
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL,
"20123456", "20123456"),
json=vips_mock.status_with_no_disclosure(
"IRP", review_start_date),
status=200,
match_querystring=True)
def mock_publish(queue_name: str, payload: bytes):
assert queue_name == "DF.hold"
monkeypatch.setattr(Config, "ENCRYPT_KEY", "something-secret")
monkeypatch.setattr(RabbitMQ, "publish", mock_publish)
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=RabbitMQ)
def test_when_an_applicants_review_has_concluded_the_disclosure_event_is_deleted(
monkeypatch):
message_dict = helper.load_json_into_dict(
'python/common/tests/sample_data/form/disclosure_payload.json')
message_dict['hold_until'] = (datetime.datetime.now() -
datetime.timedelta(hours=1)).isoformat()
tz = pytz.timezone('America/Vancouver')
review_start_date = vips.vips_datetime(
datetime.datetime.now(tz) - datetime.timedelta(days=1))
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL,
"20123456", "20123456"),
json=vips_mock.status_applied_paid_and_scheduled(
"IRP", review_start_date),
status=200,
match_querystring=True)
def mock_any_disclosure(*args, **kwargs):
# We should never call this method
assert False
monkeypatch.setattr(middleware, "is_any_unsent_disclosure",
mock_any_disclosure)
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=RabbitMQ)
def test_when_one_document_not_disclosed_one_document_is_emailed_to_applicant(
monkeypatch):
message_dict = helper.load_json_into_dict(
'python/common/tests/sample_data/form/disclosure_payload.json')
message_dict['hold_until'] = (datetime.datetime.now() -
datetime.timedelta(hours=1)).isoformat()
tz = pytz.timezone('America/Vancouver')
review_start_date = vips.vips_datetime(
datetime.datetime.now(tz) + datetime.timedelta(days=2))
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL,
"20123456", "20123456"),
json=vips_mock.status_with_one_sent_on_unsent_disclosure(
"IRP", review_start_date),
status=200,
match_querystring=True)
responses.add(responses.GET,
'{}/{}/disclosure/{}'.format(Config.VIPS_API_ROOT_URL, "111",
"20123456"),
json=vips_mock.disclosure_get(),
status=200,
match_querystring=True)
responses.add(responses.PATCH,
'{}/disclosure/{}'.format(Config.VIPS_API_ROOT_URL,
"20123456"),
json=vips_mock.disclosure_get(),
status=200,
match_querystring=True)
responses.add(responses.POST,
'{}/realms/{}/protocol/openid-connect/token'.format(
Config.COMM_SERV_AUTH_URL, Config.COMM_SERV_REALM),
json={"access_token": "token"},
status=200)
responses.add(responses.POST,
'{}/api/v1/email'.format(Config.COMM_SERV_API_ROOT_URL),
json={"sample": "test"},
status=200)
def mock_publish(queue_name: str, payload: bytes):
assert queue_name == "DF.hold"
return True
monkeypatch.setattr(Config, "ENCRYPT_KEY", "something-secret")
monkeypatch.setattr(RabbitMQ, "publish", mock_publish)
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=RabbitMQ)
email_payload = json.loads(responses.calls[3].request.body.decode())
assert '*****@*****.**' in email_payload['to']
assert len(email_payload['attachments']) == 1
def test_prohibition_exists_in_vips_method(response_from_vips, expected):
vips_status = load_json_into_dict(
"python/common/tests/sample_data/vips/{}".format(response_from_vips))
result, data = middleware.prohibition_exists_in_vips(
vips_status=vips_status)
assert result is expected
if result:
assert 'vips_data' in data
def test_application_form_received(prohibition_type, date_served, today_is,
seized, last_name, is_valid, is_applied,
email_text, monkeypatch):
def mock_status_get(*args, **kwargs):
print('inside mock_status_get()')
is_response_successful, data = status_gets(is_valid == "True",
prohibition_type,
date_served, last_name,
seized, "N/A", is_applied)
if is_response_successful and 'resp' in data:
return True, data
return False, dict({})
def mock_send_email(*args, **kwargs):
print('inside mock_send_email()')
assert "*****@*****.**" in args[0]
print("Subject: {}".format(args[1]))
assert email_text in args[3]
return True
def mock_datetime_now(**args):
args['today_date'] = helper.localize_timezone(
datetime.datetime.strptime(today_is, "%Y-%m-%d"))
print('inside mock_datetime_now: {}'.format(args.get('today_date')))
return True, args
def mock_application_save(**args):
print('inside mock_application_save()')
return True, args
def mock_add_to_hold(**args):
print('inside mock_add_to_hold()')
return True, args
monkeypatch.setattr(actions, "add_to_hold_queue", mock_add_to_hold)
monkeypatch.setattr(middleware, "determine_current_datetime",
mock_datetime_now)
monkeypatch.setattr(middleware, "save_application_to_vips",
mock_application_save)
monkeypatch.setattr(vips, "status_get", mock_status_get)
monkeypatch.setattr(common_email_services, "send_email", mock_send_email)
message_dict = helper.load_json_into_dict(
'python/tests/sample_data/form/irp_form_submission.json')
# For the prohibition_not_found and the prohibition_not_found_yet emails, we rely on users entering
# correct prohibition number prefix to determine the correct letter type.
if prohibition_type == "UL":
message_dict['prohibition_review']['form']['prohibition-information'][
'control-is-ul'] = "true"
message_dict['prohibition_review']['form']['prohibition-information'][
'control-is-irp'] = "false"
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
def test_disclosure_event_processing(
prohibition_type, today_is, review_start_date, is_valid, disclosure, attachments_expected, monkeypatch):
def mock_status_get(*args, **kwargs):
print('inside mock_status_get()')
return status_gets(is_valid == "True", prohibition_type, review_start_date, disclosure)
def mock_send_email(*args, **kwargs):
print('inside mock_send_email()')
assert "*****@*****.**" in args[0]
print("Subject: {}".format(args[1]))
return True
def mock_datetime_now(**args):
args['today_date'] = helper.localize_timezone(datetime.datetime.strptime(today_is, "%Y-%m-%d"))
print('inside mock_datetime_now: {}'.format(args.get('today_date')))
return True, args
def mock_add_to_hold(**args):
print("inside mock_add_to_hold")
return True, args
def mock_disclosure_get(*args):
print("inside mock_disclosure_get()")
data = dict({
"resp": "success",
"data": {
"document": {
"document": "base64_string_of_encoded_document",
"mimeType": "application/pdf"
}
}
})
return True, data
def mock_patch(*args):
return True, dict({})
monkeypatch.setattr(middleware, "determine_current_datetime", mock_datetime_now)
monkeypatch.setattr(vips, "status_get", mock_status_get)
monkeypatch.setattr(vips, "patch", mock_patch)
monkeypatch.setattr(common_email_services, "send_email", mock_send_email)
monkeypatch.setattr(actions, "add_to_hold_queue", mock_add_to_hold)
monkeypatch.setattr(vips, "disclosure_get", mock_disclosure_get)
message_dict = helper.load_json_into_dict('python/tests/sample_data/form/disclosure_payload.json')
results = helper.middle_logic(helper.get_listeners(business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
if attachments_expected > 0:
assert 'disclosure_for_applicant' in results
assert len(results.get('disclosure_for_applicant')) == attachments_expected
else:
assert 'disclosure_for_applicant' not in results
def _get_resource(**kwargs) -> tuple:
resource = kwargs.get('resource')
try:
data = helper.load_json_into_dict(
'python/prohibition_web_svc/data/{}.json'.format(resource))
kwargs['response'] = make_response(data, 200)
return True, kwargs
except Exception as e:
logging.warning("error getting {} data".format(resource))
return False, kwargs
def test_user_submitted_last_name_matches_vips_method(user_entered_last_name,
last_name_from_vips,
expected):
vips_status = load_json_into_dict(
"python/common/tests/sample_data/vips/vips_query_200.json")
vips_status['data']['status']['surnameNm'] = last_name_from_vips
result, args = middleware.user_submitted_last_name_matches_vips(
driver_last_name=user_entered_last_name,
vips_data=vips_status['data']['status'])
assert result is expected
def _get_agencies(**kwargs) -> tuple:
try:
static = helper.load_json_into_dict(
'python/prohibition_web_svc/data/agencies.json')
ids = [o['id'] for o in static]
kwargs['response'] = make_response(jsonify(ids), 200)
return True, kwargs
except Exception as e:
logging.warning("error getting static data")
return False, kwargs
def test_etk_endpoint_rejects_ticket_issuance_if_not_published_to_rabbitmq(
as_authorized_user, caplog, monkeypatch):
monkeypatch.setattr(routes, "RabbitMQ", MockRabbitPublishFail)
payload = load_json_into_dict(
"python/common/tests/sample_data/etk/event_issuance.json")
response = as_authorized_user.post('/v1/publish/event/etk', json=payload)
assert 'queue: ingested' in caplog.text
assert '"event_id": 1234' in caplog.text
assert '"event_date_time": "2020-01-20 08:23:16"' in caplog.text
assert response.status_code == 500
def test_get_data_from_schedule_form():
# check that json attributes with null values are converted to None type
sample_data = load_json_into_dict(
'python/common/tests/sample_data/form/schedule_picker_submission.json')
response, args = middleware.get_data_from_schedule_form(
message=sample_data)
assert args.get(
'requested_time_code'
) == 'MjAyMC0xMC0wNyAwOTozMDowMCAtMDc6MDB8MjAyMC0xMC0wNyAxMDowMDowMCAtMDc6MDA='
assert args.get('prohibition_number') == '21-900040'
assert args.get('driver_last_name') == 'Gordon'
def test_health_check_method():
response = load_json_into_dict(
'python/common/tests/sample_data/vips/vips_health_check_200.json')
vips.get = MagicMock(return_value=(True, response))
endpoint = TestConfig.VIPS_API_ROOT_URL + '/api/utility/ping'
vips.get(endpoint, TestConfig.VIPS_API_USERNAME,
TestConfig.VIPS_API_PASSWORD)
is_success, actual = vips.health_get(TestConfig)
vips.get.assert_called_with(endpoint, TestConfig.VIPS_API_USERNAME,
TestConfig.VIPS_API_PASSWORD)
print(json.dumps(actual))
assert is_success is True
assert "responseMessage" in actual
def test_disclosure_get_method():
response_from_api = load_json_into_dict(
'python/common/tests/sample_data/vips/vips_disclosure_200.json')
vips.get = MagicMock(return_value=(True, response_from_api))
endpoint = TestConfig.VIPS_API_ROOT_URL + '/1234/disclosure/' + TestVips.CORRELATION_ID
vips.get(endpoint, TestConfig.VIPS_API_USERNAME,
TestConfig.VIPS_API_PASSWORD)
is_success, actual = vips.disclosure_get("1234", TestConfig,
TestVips.CORRELATION_ID)
vips.get.assert_called_with(endpoint, TestConfig.VIPS_API_USERNAME,
TestConfig.VIPS_API_PASSWORD,
TestVips.CORRELATION_ID)
assert is_success is True
assert "document" in actual['data']
def test_query_get_method_failure():
response_from_api = load_json_into_dict(
'python/common/tests/sample_data/vips/vips_query_404.json')
vips.get = MagicMock(return_value=(True, response_from_api))
endpoint = TestConfig.VIPS_API_ROOT_URL + '/12345/status/' + TestVips.CORRELATION_ID
vips.get(endpoint, TestConfig.VIPS_API_USERNAME,
TestConfig.VIPS_API_PASSWORD)
is_success, actual = vips.status_get("12345", TestConfig,
TestVips.CORRELATION_ID)
vips.get.assert_called_with(endpoint, TestConfig.VIPS_API_USERNAME,
TestConfig.VIPS_API_PASSWORD,
TestVips.CORRELATION_ID)
print(json.dumps(actual))
assert is_success is True
assert "fail" in actual['resp']
def test_query_get_method_success():
response_from_api = load_json_into_dict(
'python/tests/sample_data/vips/vips_query_200.json')
vips.get = MagicMock(return_value=(True, response_from_api))
endpoint = TestConfig.VIPS_API_ROOT_URL + '/12345/status/' + TestVips.CORRELATION_ID
vips.get(endpoint, TestConfig.VIPS_API_USERNAME,
TestConfig.VIPS_API_PASSWORD)
is_success, actual = vips.status_get("12345", TestConfig,
TestVips.CORRELATION_ID)
vips.get.assert_called_with(endpoint, TestConfig.VIPS_API_USERNAME,
TestConfig.VIPS_API_PASSWORD,
TestVips.CORRELATION_ID)
print(json.dumps(actual))
assert is_success is True
assert "driverLicenceSeizedYn" in actual['data']['status']
assert "surnameNm" in actual['data']['status']
assert "disclosure" in actual['data']['status']
def test_transform_schedule_to_local_friendly_times():
vips_response = load_json_into_dict(
'python/common/tests/sample_data/vips/vips_schedule_200.json')
time_slots = vips_response['data']['timeSlots']
print(json.dumps(time_slots[0]))
print(str(type(time_slots[0])))
friendly_times_list = vips.time_slots_to_friendly_times(
time_slots, "ORAL")
expected = list([
"Fri, Sep 4, 2020 - 9:00AM to 9:30AM (Pacific Time)",
"Fri, Sep 4, 2020 - 10:00AM to 10:30AM (Pacific Time)",
"Fri, Sep 4, 2020 - 11:00AM to 11:30AM (Pacific Time)",
"Fri, Sep 4, 2020 - 12:00PM to 12:30PM (Pacific Time)",
"Fri, Sep 4, 2020 - 1:00PM to 1:30PM (Pacific Time)"
])
for index, item in enumerate(expected):
assert friendly_times_list[index]['label'] == item
def test_applicant_sent_email_confirming_evidence_received(monkeypatch):
tz = pytz.timezone('America/Vancouver')
review_start_date = vips.vips_datetime(
datetime.datetime.now(tz) + datetime.timedelta(days=1))
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL,
"20123456", "20123456"),
json=vips_mock.status_applied_paid_and_scheduled(
"IRP", review_start_date),
status=200,
match_querystring=True)
responses.add(responses.GET,
'{}/{}/application/{}'.format(
Config.VIPS_API_ROOT_URL,
"bb71037c-f87b-0444-e054-00144ff95452", "20123456"),
json=vips_mock.application_get(),
status=200)
def mock_send_email(*args, **kwargs):
print('inside mock_send_email()')
assert "*****@*****.**" in args[0]
print("Subject: {}".format(args[1]))
assert "Evidence Received - Driving Prohibition 20-123456 Review" in args[
3]
assert "we received the evidence that will be considered for your review." in args[
3]
assert "http://link-to-evidence-form" in args[3]
return True
monkeypatch.setattr(common_email_services, "send_email", mock_send_email)
message_dict = helper.load_json_into_dict(
'python/common/tests/sample_data/form/document_submission.json')
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
if "error_string" in results:
print(results.get('error_string'))
assert 'error_string' not in results
def test_evidence_form_received(prohibition_type, date_served, today_is,
seized, last_name, is_valid, is_applied,
email_text, monkeypatch):
def mock_status_get(*args, **kwargs):
print('inside mock_status_get()')
return status_gets(is_valid == "True", prohibition_type, date_served,
last_name, seized, "N/A", is_applied)
def mock_application_get(*args, **kwargs):
print('inside mock_application_get()')
return application_get()
def mock_send_email(*args, **kwargs):
print('inside mock_send_email()')
assert "*****@*****.**" in args[0]
print("Subject: {}".format(args[1]))
assert email_text in args[3]
return True
def mock_datetime_now(**args):
args['today_date'] = helper.localize_timezone(
datetime.datetime.strptime(today_is, "%Y-%m-%d"))
print('inside mock_datetime_now: {}'.format(args.get('today_date')))
return True, args
monkeypatch.setattr(middleware, "determine_current_datetime",
mock_datetime_now)
monkeypatch.setattr(vips, "status_get", mock_status_get)
monkeypatch.setattr(vips, "application_get", mock_application_get)
monkeypatch.setattr(common_email_services, "send_email", mock_send_email)
message_dict = helper.load_json_into_dict(
'python/tests/sample_data/form/document_submission.json')
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
if "error_string" in results:
print(results.get('error_string'))
assert 'error_string' not in results
def test_disclosure_that_has_not_reached_the_hold_until_datetime_is_placed_back_on_hold(
monkeypatch):
message_dict = helper.load_json_into_dict(
'python/common/tests/sample_data/form/disclosure_payload.json')
message_dict['hold_until'] = (datetime.datetime.now() +
datetime.timedelta(hours=1)).isoformat()
def mock_publish(queue_name: str, payload: bytes):
assert queue_name == "DF.hold"
return True
monkeypatch.setattr(Config, "ENCRYPT_KEY", "something-secret")
monkeypatch.setattr(RabbitMQ, "publish", mock_publish)
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=RabbitMQ)
def get_sample_application_submission(prohibition_type: str = "IRP") -> dict:
message_dict = helper.load_json_into_dict(
'python/common/tests/sample_data/form/irp_form_submission.json')
event_type = message_dict['event_type']
if prohibition_type == "UL":
message_dict[event_type]['form']['prohibition-information'][
'control-is-adp'] = "false"
message_dict[event_type]['form']['prohibition-information'][
'control-is-irp'] = "false"
message_dict[event_type]['form']['prohibition-information'][
'control-is-ul'] = "true"
elif prohibition_type == "ADP":
message_dict[event_type]['form']['prohibition-information'][
'control-is-adp'] = "true"
message_dict[event_type]['form']['prohibition-information'][
'control-is-irp'] = "false"
message_dict[event_type]['form']['prohibition-information'][
'control-is-ul'] = "false"
return message_dict
def test_an_applicant_that_was_served_recently_and_where_prohibition_is_not_in_vips_gets_not_yet_email(
monkeypatch):
def mock_status_get(*args, **kwargs):
return True, dict({
"resp": "fail",
"error": {
"message": "Record not found",
"httpStatus": 404
}
})
def mock_send_email(*args, **kwargs):
template_content = args[3]
print('inside mock_send_email()')
assert "*****@*****.**" in args[0]
print("Subject: {}".format(args[1]))
assert "issued on September 22, 2020 isn't in our" in template_content
return True
def mock_datetime_now(**args):
args['today_date'] = helper.localize_timezone(
datetime.datetime.strptime("2020-09-23", "%Y-%m-%d"))
print('inside mock_datetime_now: {}'.format(args.get('today_date')))
return True, args
def mock_add_to_hold(**args):
print('inside mock_add_to_hold()')
return True, args
monkeypatch.setattr(actions, "add_to_hold_queue", mock_add_to_hold)
monkeypatch.setattr(middleware, "determine_current_datetime",
mock_datetime_now)
monkeypatch.setattr(vips, "status_get", mock_status_get)
monkeypatch.setattr(common_email_services, "send_email", mock_send_email)
message_dict = helper.load_json_into_dict(
'python/tests/sample_data/form/irp_form_submission.json')
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
def test_null_json_values_convert_to_none_types():
# check that json attributes with null values are converted to None type
sample_data = load_json_into_dict(
'python/common/tests/sample_data/form/irp_form_submission.json')
assert sample_data['prohibition_review']['form']['review-information'][
'ul-grounds'] is None
def convert_to_tables(filename):
mapper = Mapper(WriterConfig())
sample_message = load_json_into_dict(
'python/common/tests/sample_data/etk/' + filename)
return mapper.convert_to_tables(sample_message)
from functools import wraps
import python.common.rsi_email as rsi_email
application = FlaskAPI(__name__)
application.secret = Config.FLASK_SECRET_KEY
logging.basicConfig(level=Config.LOG_LEVEL, format=Config.LOG_FORMAT)
logging.warning('*** flask initialized ***')
@application.before_request
def before_request_function():
g.writer = RabbitMQ(Config())
available_parameters = helper.load_json_into_dict('python/ingestor/' + Config.PARAMETERS_FILE)
def basic_auth_required(f):
"""
Decorator that implements basic auth when added to a route
"""
@wraps(f)
def decorated(*args, **kwargs):
auth = request.authorization
if not auth or not helper.check_credentials(
Config.FLASK_BASIC_AUTH_USER, Config.FLASK_BASIC_AUTH_PASS, auth.username, auth.password):
message = {'error': 'Unauthorized'}
resp = jsonify(message)
resp.status_code = 401
return resp
def load_roles_and_permissions_from_static_file(**kwargs) -> tuple:
permissions = load_json_into_dict(
"python/prohibition_web_svc/data/permissions.json")
kwargs['permissions'] = permissions
return permissions is not None, kwargs
def test_last_name_match():
response_from_api = load_json_into_dict(
'python/common/tests/sample_data/vips/vips_query_200.json')
is_success = vips.is_last_name_match(
response_from_api['data']['status'], "Norris")
assert is_success is True
