def test_an_unlicenced_applicant_that_applies_using_incorrect_last_name_gets_appropriate_email(
):
date_served = "2020-09-23"
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL,
"21999344", "21999344"),
json=vips_mock.status_has_never_applied(
"UL", date_served, "Wrong"),
status=404,
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={"response": "ignored"},
status=200)
message_dict = get_sample_application_submission("UL")
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
email_payload = json.loads(responses.calls[2].request.body.decode())
assert "*****@*****.**" in email_payload['to']
assert "Prohibition Number or Name Don't Match - Driving Prohibition 21-999344 Review" == email_payload[
'subject']
assert "You can re-apply at any time." in email_payload['body']
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_an_unlicenced_applicant_that_had_a_successful_review_cannot_apply_again(
):
responses.add(
responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL, "21999344",
"21999344"),
json=vips_mock.status_previously_applied_review_successful("UL"),
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={"response": "ignored"},
status=200)
message_dict = get_sample_application_submission("UL")
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
email_payload = json.loads(responses.calls[2].request.body.decode())
assert "*****@*****.**" in email_payload['to']
assert "Previous Review on File – Driving Prohibition 21-999344 Review" == email_payload[
'subject']
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_a_successful_applicant_gets_an_application_accepted_email(
prohib, monkeypatch):
date_served = "2021-02-19"
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL,
"21999344", "21999344"),
json=vips_mock.status_has_never_applied(prohib, date_served),
status=200,
match_querystring=True)
responses.add(responses.POST,
'{}/{}/{}/application/{}'.format(Config.VIPS_API_ROOT_URL,
prohib, "21999344",
"21999344"),
json={},
status=200)
responses.add(responses.POST,
"{}:{}/services/collector".format(Config.SPLUNK_HOST,
Config.SPLUNK_PORT),
status=200)
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={"response": "ignored"},
status=200)
def mock_datetime_now(**args):
args['today_date'] = helper.localize_timezone(
datetime.datetime.strptime("2021-02-23", "%Y-%m-%d"))
return True, args
monkeypatch.setattr(middleware, "determine_current_datetime",
mock_datetime_now)
message_dict = get_sample_application_submission(prohib)
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
email_payload = json.loads(responses.calls[4].request.body.decode())
assert "*****@*****.**" in email_payload['to']
assert "Application Accepted - Driving Prohibition 21-999344 Review" == email_payload[
'subject']
assert "Your application for a review of driving prohibition 21999344 has been accepted." in email_payload[
'body']
assert "You must pay in full by credit card by February 27, 2021" in email_payload[
'body']
assert "If you don't pay by February 27, 2021, your review will not go ahead." in email_payload[
'body']
assert "http://link-to-paybc" in email_payload['body']
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_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 test_an_applicant_that_was_served_7_days_ago_but_not_in_vips_gets_still_not_found_email(
prohib, monkeypatch):
def mock_datetime_now(**args):
args['today_date'] = helper.localize_timezone(
datetime.datetime.strptime("2020-09-29", "%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
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL,
"21999344", "21999344", "21999344"),
json=vips_mock.status_not_found(),
status=404,
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={"response": "ignored"},
status=200)
monkeypatch.setattr(actions, "add_to_hold_queue", mock_add_to_hold)
monkeypatch.setattr(middleware, "determine_current_datetime",
mock_datetime_now)
message_dict = get_sample_application_submission(prohib)
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
email_payload = json.loads(responses.calls[2].request.body.decode())
assert "*****@*****.**" in email_payload['to']
assert "Prohibition Still Not Found - Driving Prohibition 21-999344" in email_payload[
'subject']
assert "If it's not in our system by the next time we check, your online" in email_payload[
'body']
assert "You can't get a review extension if you miss the deadline" in email_payload[
'body']
assert "http://link-to-icbc" in email_payload['body']
assert "http://link-to-service-bc" in email_payload['body']
def test_an_unlicenced_successful_applicant_gets_an_application_accepted_email(
):
date_served = (datetime.datetime.now() -
datetime.timedelta(days=6)).strftime("%Y-%m-%d")
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL,
"21999344", "21999344"),
json=vips_mock.status_has_never_applied("UL", date_served),
status=200,
match_querystring=True)
responses.add(responses.POST,
'{}/{}/{}/application/{}'.format(Config.VIPS_API_ROOT_URL,
"UL", "21999344",
"21999344"),
json={},
status=200)
responses.add(responses.POST,
"{}:{}/services/collector".format(Config.SPLUNK_HOST,
Config.SPLUNK_PORT),
status=200)
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={"response": "ignored"},
status=200)
message_dict = get_sample_application_submission("UL")
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
email_payload = json.loads(responses.calls[4].request.body.decode())
assert "*****@*****.**" in email_payload['to']
assert "Application Accepted - Driving Prohibition 21-999344 Review" == email_payload[
'subject']
assert "Your application for a review of driving prohibition 21999344 has been accepted." in email_payload[
'body']
assert "You must pay in full by credit card within 7 days of applying for this review." in email_payload[
'body']
assert "http://link-to-paybc" in email_payload['body']
def test_an_unlicenced_applicant_that_has_previously_applied_gets_application_accepted(
):
"""
UL applicants can apply multiple times, other prohibition types can only apply once
"""
responses.add(
responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL, "21999344",
"21999344"),
json=vips_mock.status_previously_applied_review_unsuccessful("UL"),
status=200,
match_querystring=True)
responses.add(responses.POST,
'{}/{}/{}/application/{}'.format(Config.VIPS_API_ROOT_URL,
"UL", "21999344",
"21999344"),
json={},
status=200)
responses.add(responses.POST,
"{}:{}/services/collector".format(Config.SPLUNK_HOST,
Config.SPLUNK_PORT),
status=200)
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={"response": "ignored"},
status=200)
message_dict = get_sample_application_submission("UL")
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
email_payload = json.loads(responses.calls[4].request.body.decode())
assert "*****@*****.**" in email_payload['to']
assert "Application Accepted - Driving Prohibition 21-999344 Review" == email_payload[
'subject']
def test_verify_schedule_event_that_has_not_reached_the_hold_until_datetime_is_placed_back_on_hold(
monkeypatch):
future_date = datetime.datetime.now() + datetime.timedelta(hours=1)
message_dict = get_verify_schedule_event(future_date)
def mock_publish(queue_name: str, payload: bytes):
assert queue_name == "DF.hold"
return True
monkeypatch.setattr(BaseConfig, "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=BaseConfig,
writer=RabbitMQ)
def callback(self, ch, method, properties, body):
# convert body (in bytes) to string
message_dict = decode_message(body, self.config.ENCRYPT_KEY)
logging.info("callback() invoked: {}".format(json.dumps(message_dict)))
helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=self.config,
writer=self.writer)
# Regardless of whether the process above follows the happy path or not,
# we need to acknowledge receipt of the message to RabbitMQ below. This
# acknowledgement deletes it from the queue. The logic above
# must have saved / handled the message before we get here.
ch.basic_ack(delivery_tag=method.delivery_tag)
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_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_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 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_an_irp_applicant_that_applies_at_icbc_gets_already_applied_email():
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,
"21999344", "21999344"),
json=vips_mock.status_applied_at_icbc(
"IRP", review_start_date),
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={"response": "ignored"},
status=200)
message_dict = get_sample_application_submission("IRP")
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
email_payload = json.loads(responses.calls[2].request.body.decode())
assert "*****@*****.**" in email_payload['to']
assert "Dear Applicant," in email_payload['body']
assert "Applied at ICBC - Driving Prohibition 21-999344 Review" == email_payload[
'subject']
assert "Our records show that an application to review prohibition 21999344" in email_payload[
'body']
assert "has been paid and scheduled at ICBC" in email_payload['body']
assert "Please do not respond to this email." in email_payload['body']
def test_an_applicant_without_a_valid_prohibition_gets_appropriate_email(
prohib, monkeypatch):
"""
Applicant gets the "Not Found" email if the date served (as entered by the applicant)
has allowed sufficient time for the prohibition to be entered into VIPS
"""
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL,
"21999344", "21999344"),
json=vips_mock.status_not_found(),
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={"response": "ignored"},
status=200)
message_dict = get_sample_application_submission(prohib)
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
email_payload = json.loads(responses.calls[2].request.body.decode())
assert "*****@*****.**" in email_payload['to']
assert "Prohibition Not Found and 7-day Application Window Missed - Driving Prohibition 21-999344 Review" in email_payload[
'subject']
assert "Your application for a review of the prohibition can't be accepted." in email_payload[
'body']
def test_an_applicant_that_has_missed_the_window_to_apply_gets_appropriate_email(
prohib, monkeypatch):
tz = pytz.timezone('America/Vancouver')
date_served = (datetime.datetime.now(tz) -
datetime.timedelta(days=8)).strftime("%Y-%m-%d")
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL,
"21999344", "21999344"),
json=vips_mock.status_has_never_applied(prohib, date_served),
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={"response": "ignored"},
status=200)
message_dict = get_sample_application_submission(prohib)
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
email_payload = json.loads(responses.calls[2].request.body.decode())
assert "*****@*****.**" in email_payload['to']
assert "7-day Application Window Missed - Driving Prohibition 21-999344 Review" == email_payload[
'subject']
assert "Your application for a review of driving prohibition 21999344 can't be accepted." in email_payload[
'body']
assert "Our records show your Notice of Prohibition was issued more than 7 days ago." in email_payload[
'body']
def test_verify_schedule_event_sends_email_to_business_if_applicant_has_not_scheduled(
monkeypatch):
past_date = datetime.datetime.now() - datetime.timedelta(hours=1)
message_dict = get_verify_schedule_event(past_date)
business_email_address = "*****@*****.**"
responses.add(responses.GET,
'{}/{}/status/{}'.format(BaseConfig.VIPS_API_ROOT_URL,
"20123456", "20123456"),
json=vips_mock.status_applied_and_paid_not_scheduled("IRP"),
status=200,
match_querystring=True)
def mock_send_business_email(*args, **kwargs):
assert "Did Not Schedule - Driving Prohibition 20-123456 Review" in args[
0]
assert "Appeals Registry," in args[2]
assert "Charlie Brown, the applicant of prohibition 20123456," in args[
2]
assert "did not schedule the review within 24 hours of payment." in args[
2]
assert "Number: ABCD-1234" in args[2]
assert "Amount: 50.00" in args[2]
assert "Date: 2020-10-22" in args[2]
assert "Order Number: 1010100" in args[2]
return True
monkeypatch.setattr(BaseConfig, "BCC_EMAIL_ADDRESSES",
business_email_address)
monkeypatch.setattr(common_email, "send_to_business",
mock_send_business_email)
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=BaseConfig,
writer=RabbitMQ)
def test_an_irp_or_adp_applicant_that_has_previously_applied_gets_appropriate_email(
prohib, monkeypatch):
date_served = datetime.datetime.now().strftime("%Y-%m-%d")
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL,
"21999344", "21999344"),
json=vips_mock.status_applied_not_paid(prohib, date_served),
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={"response": "ignored"},
status=200)
message_dict = get_sample_application_submission(prohib)
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
email_payload = json.loads(responses.calls[2].request.body.decode())
assert "*****@*****.**" in email_payload['to']
assert "Already Applied – Driving Prohibition 21-999344 Review" == email_payload[
'subject']
assert "An application to review prohibition 21999344 has already been submitted." in email_payload[
'body']
assert "You must call to make changes to your application." in email_payload[
'body']
def test_an_applicant_that_has_not_surrendered_their_licence_gets_appropriate_email(
prohib, monkeypatch):
date_served = datetime.datetime.now().strftime("%Y-%m-%d")
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL,
"21999344", "21999344"),
json=vips_mock.status_has_never_applied(
prohib, date_served, "Gordon", "N"),
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={"response": "ignored"},
status=200)
message_dict = get_sample_application_submission(prohib)
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=Config,
writer=None)
email_payload = json.loads(responses.calls[2].request.body.decode())
assert "*****@*****.**" in email_payload['to']
assert "Licence Not Surrendered - Driving Prohibition 21-999344 Review" == email_payload[
'subject']
assert "You're ineligible to apply online because your licence wasn't surrendered" in email_payload[
'body']
def test_verify_schedule_check_placed_back_on_hold_if_vips_not_available(
monkeypatch):
past_date = datetime.datetime.now() + datetime.timedelta(hours=1)
message_dict = get_verify_schedule_event(past_date)
responses.add(responses.GET,
'{}/{}/status/{}'.format(BaseConfig.VIPS_API_ROOT_URL,
"20123456", "20123456"),
json=vips_mock.status_returns_html_response(),
status=200,
match_querystring=True)
def mock_publish(queue_name: str, payload: bytes):
assert queue_name == "DF.hold"
return True
monkeypatch.setattr(BaseConfig, "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=BaseConfig,
writer=RabbitMQ)
def test_verify_no_email_sent_to_business_if_applicant_scheduled(monkeypatch):
past_date = datetime.datetime.now() - datetime.timedelta(hours=1)
message_dict = get_verify_schedule_event(past_date)
responses.add(responses.GET,
'{}/{}/status/{}'.format(BaseConfig.VIPS_API_ROOT_URL,
"20123456", "20123456"),
json=vips_mock.status_applied_paid_and_scheduled(
"IRP", "2021-03-24 12:00:00 -0700"),
status=200,
match_querystring=True)
def mock_send_business_email(*args, **kwargs):
# this method should never be called
assert False
monkeypatch.setattr(common_email, "send_to_business",
mock_send_business_email)
results = helper.middle_logic(helper.get_listeners(
business.process_incoming_form(), message_dict['event_type']),
message=message_dict,
config=BaseConfig,
writer=RabbitMQ)
def test_disclosure_email_template_has_unique_text_for_ul_prohibitions(
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_two_unsent_disclosures(
"UL", review_start_date),
status=200,
match_querystring=True)
def mock_publish(queue_name: str, payload: bytes):
assert queue_name == "DF.hold"
return True
#
# def mock_send_email(*args, **kwargs):
# print('inside mock_send_email()')
# assert "*****@*****.**" in args[0]
# assert "Disclosure Documents Attached - Driving Prohibition 20-123456 Review" in args[1]
# assert "Attached is the police evidence the RoadSafetyBC adjudicator will consider in your review." in args[3]
# assert '<a href="http://localhost">get a copy from ICBC</a>' in args[3]
# return 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.GET,
'{}/{}/disclosure/{}'.format(Config.VIPS_API_ROOT_URL, "222",
"20123456"),
json=vips_mock.disclosure_get(),
status=200,
match_querystring=True)
responses.add(responses.PATCH,
'{}/disclosure/{}'.format(Config.VIPS_API_ROOT_URL,
"20123456"),
json=dict({}),
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)
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[4].request.body.decode())
assert '*****@*****.**' in email_payload['to']
assert email_payload[
'subject'] == "Disclosure Documents Attached - Driving Prohibition 20-123456 Review"
assert "Attached is the police evidence the RoadSafetyBC adjudicator will consider in your review." in email_payload[
'body']
assert '<a href="http://localhost">get a copy from ICBC</a>' in email_payload[
'body']
def test_an_applicant_can_schedule_a_written_review(monkeypatch):
today = "2020-09-23"
payment_date = "2020-12-05"
application_id = "bb71037c-f87b-0444-e054-00144ff95452"
prohibtion_num = "21900040"
time_slot = vips.encode_time_slot({
"reviewStartDtm": "2020-12-09 11:00:00 -08:00",
"reviewEndDtm": "2020-12-09 11:30:00 -08:00",
})
responses.add(responses.GET,
'{}/{}/status/{}'.format(Config.VIPS_API_ROOT_URL, prohibtion_num, prohibtion_num, prohibtion_num),
json=vips_mock.status_applied_and_paid_not_scheduled("IRP"),
status=200, match_querystring=True)
responses.add(responses.GET,
'{}/{}/payment/status/{}'.format(
Config.VIPS_API_ROOT_URL, application_id , prohibtion_num),
json=vips_mock.payment_get(payment_date),
status=200)
responses.add(responses.GET,
'{}/{}/application/{}'.format(
Config.VIPS_API_ROOT_URL, application_id, prohibtion_num),
json=vips_mock.application_get("WRIT"),
status=200)
responses.add(responses.POST,
'{}/{}/review/schedule/{}'.format(
Config.VIPS_API_ROOT_URL, application_id, prohibtion_num),
json={"timeSlot": time_slot},
status=201)
responses.add(responses.POST, "{}:{}/services/collector".format(
Config.SPLUNK_HOST, Config.SPLUNK_PORT), status=200)
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={"response": "ignored"}, status=201)
def mock_datetime_now(**args):
args['today_date'] = helper.localize_timezone(datetime.datetime.strptime(today, "%Y-%m-%d"))
print('inside mock_datetime_now: {}'.format(args.get('today_date')))
return True, args
def mock_publish(queue_name: str, payload: bytes):
assert queue_name == "DF.hold"
return True
monkeypatch.setattr(BaseConfig, "ENCRYPT_KEY", "something-secret")
monkeypatch.setattr(RabbitMQ, "publish", mock_publish)
monkeypatch.setattr(middleware, "determine_current_datetime", mock_datetime_now)
message_dict = get_sample_schedule_review_submission("21999344", "Gordon", time_slot)
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[6].request.body.decode())
assert "*****@*****.**" in email_payload['to']
assert "Review Date Confirmed - Driving Prohibition 21-900040 Review" in email_payload['subject']
assert "We can only change the review date or time in special situations." in email_payload['body']
assert "Your written review has been scheduled for:" in email_payload['body']
assert "Wed, Dec 9, 2020 at 9:30AM (Pacific Time)" in email_payload['body']
