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): helper.middle_logic([ { "try": splunk_middleware.basic_authentication_failed, "fail": [] }, { "try": splunk.log_to_splunk, "fail": [] }, ], config=Config, request=request) logging.warning( "Request denied - unauthorized - IP Address: {}".format( request.remote_addr)) message = {'error': 'Unauthorized'} resp = jsonify(message) resp.status_code = 401 return resp return f(*args, **kwargs)
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_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_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 index(): """ List all forms """ if request.method == 'GET': kwargs = helper.middle_logic([{ "try": splunk_middleware.admin_get_forms, "fail": [] }, { "try": splunk.log_to_splunk, "fail": [] }, { "try": form_middleware.admin_list_all_forms_by_type, "fail": [ { "try": http_responses.server_error_response, "fail": [] }, ] }], form_type=request.args.get('type'), request=request, config=Config) return kwargs.get('response')
def schedule(): """ Confirm prohibition number and last name matches VIPS. Return list of possible review dates for given prohibition. Note: using POST instead of GET to allow last names with special characters from Orbeon. """ if request.method == 'POST': # invoke middleware functions args = helper.middle_logic(business.get_available_time_slots(), prohibition_number=request.form['prohibition_number'], driver_last_name=request.form['last_name'], config=Config) if 'error_string' not in args: return jsonify(dict({ "data": { "is_valid": True, "presentation_type": args.get('presentation_type'), "time_slots": args.get('time_slots') } })) return jsonify(dict({ "data": { "is_success": False, "error": args.get('error_string'), "timeSlots": [] } }))
def index(form_type): """ List all forms for a user """ if request.method == 'GET': kwargs = helper.middle_logic( get_authorized_keycloak_user() + [{ "try": splunk_middleware.log_form_index, "fail": [] }, { "try": form_middleware.list_all_users_forms, "fail": [ { "try": http_responses.server_error_response, "fail": [] }, ] }, { "try": splunk.log_to_splunk, "fail": [] }], required_permission='forms-index', request=request, form_type=form_type, config=Config) return kwargs.get('response')
def test_pay_bc_generate_invoice_method(prohibition_type, application_created, error, monkeypatch): is_in_vips = True prohibition_type = "ADP" today_is = "2020-09-14" last_name = "Gordon" date_served = "2020-09-10" is_paid = False def mock_status_get(*args, **kwargs): print('inside mock_status_get()') return status_get(is_in_vips, prohibition_type, date_served, last_name, is_paid, application_created) def mock_application_get(*args, **kwargs): print('inside mock_application_get()') return application_get() 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) results = helper.middle_logic(business.generate_invoice(), prohibition_number="20-123456", config=Config) print(results.get('error_string')) if error is None: assert "error_string" not in results else: assert "error_string" in results assert results.get('error_string') == error
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_search_method( prohibition_type, date_served, today_is, is_paid, last_name, is_in_vips, error, monkeypatch): def mock_status_get(*args, **kwargs): print('inside mock_status_get()') return status_get(is_in_vips, prohibition_type, date_served, last_name, is_paid, 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) results = helper.middle_logic(business.search_for_invoice(), prohibition_number="20-123456", driver_last_name="Gordon", config=Config) print(results.get('error_string')) if error is None: assert "error_string" not in results else: assert "error_string" in results assert results.get('error_string') == error
def search(): """ On the Pay_BC site, a user lookups an prohibition_number (invoice) to be paid. PayBC searches for the invoice in our system using a GET request with an invoice number and a check_value. We return an array of items to be paid. """ if request.method == 'GET': # invoke middleware business logic prohibition_number = request.args.get('invoice_number') driver_last_name = request.args.get('check_value') logging.info('inputs: {}, {}'.format(prohibition_number, driver_last_name)) args = helper.middle_logic(rules.search_for_invoice(), config=Config, prohibition_number=prohibition_number, driver_last_name=driver_last_name) if 'error_string' not in args: host_url = request.host_url.replace('http', 'https') return jsonify({ "items": [{ "selected_invoice": { "$ref": host_url + 'api_v2/invoice/' + args.get('prohibition_number') } }] }) return jsonify({"error": args.get('error_string')})
def index(): """ List all authorized users and their associated user-roles """ if request.method == 'GET': kwargs = helper.middle_logic( keycloak_logic.get_authorized_keycloak_user() + [ { "try": splunk_middleware.admin_get_users, "fail": [] }, { "try": splunk.log_to_splunk, "fail": [] }, { "try": role_middleware.query_all_users, "fail": [ { "try": http_responses.server_error_response, "fail": [] }, ] }, ], required_permission='admin_users-index', request=request, config=Config) return kwargs.get('response')
def show(prohibition_number): """ PayBC requests details on the item to be paid from this endpoint. """ if request.method == 'GET': # invoke middleware business logic args = helper.middle_logic(rules.generate_invoice(), prohibition_number=prohibition_number, config=Config) if 'error_string' not in args: presentation_type = args.get('presentation_type') amount_due = args.get('amount_due') service_date = args.get('service_date') return jsonify( dict({ "invoice_number": args.get('prohibition_number'), "pbc_ref_number": "10008", "party_number": 0, "party_name": "n/a", "account_number": "n/a", "site_number": "0", "cust_trx_type": "Review Notice of Driving Prohibition", "term_due_date": service_date.isoformat(), "total": amount_due, "amount_due": amount_due, "attribute1": args.get('notice_type_verbose'), "attribute2": service_date.strftime("%b %-d, %Y"), "attribute3": presentation_type, "amount": amount_due })) return jsonify({"error": args.get('error_string')})
def get_vehicle(plate_number): if request.method == 'GET': kwargs = middle_logic( get_authorized_keycloak_user() + [{ "try": icbc_middleware.get_icbc_api_authorization_header, "fail": [ { "try": http_responses.server_error_response, "fail": [] }, ] }, { "try": icbc_middleware.get_icbc_vehicle, "fail": [ { "try": http_responses.server_error_response, "fail": [] }, ] }, { "try": icbc_middleware.splunk_get_vehicle, "fail": [] }, { "try": splunk.log_to_splunk, "fail": [] }], required_permission='vehicle-get', plate_number=plate_number.upper(), request=request, config=Config) return kwargs.get('response')
def index(): """ List all roles for the currently logged-in user """ if request.method == 'GET': kwargs = helper.middle_logic( keycloak_logic.get_authorized_keycloak_user() + [{ "try": splunk_middleware.get_user_role, "fail": [] }, { "try": splunk.log_to_splunk, "fail": [] }, { "try": role_middleware.query_current_users_roles, "fail": [ { "try": http_responses.server_error_response, "fail": [] }, ] }], required_permission='user_roles-index', request=request, config=Config) return kwargs.get('response')
def test_okay_to_submit_evidence(prohibition_type, date_served, today_is, is_paid, last_name, is_valid, is_applied, review_start_date, expected, monkeypatch): def mock_status_get(*args, **kwargs): print('inside mock_status_get()') return status_gets(is_valid == "True", prohibition_type, date_served, is_paid, review_start_date, last_name, is_applied) def mock_datetime_now(**args): args['today_date'] = helper.localize_timezone( datetime.datetime.strptime(today_is, "%Y-%m-%d %H:%M")) 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) results = helper.middle_logic(business.is_okay_to_submit_evidence(), prohibition_number="00123456", driver_last_name="Gordon", config=Config) if expected == "True": print("error string: {}".format(results.get('error_string'))) assert 'error_string' not in results else: assert 'error_string' in results
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 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_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 callback(self, ch, method, properties, body): logging.info('message received; callback invoked') # convert body (in bytes) to string message_dict = decode_message(body, self.config.ENCRYPT_KEY) helper.middle_logic(helper.get_listeners(business.process_ekt_events(), message_dict['event_type']), message=message_dict, config=self.config, writer=self.writer) # Regardless of whether the write above is successful we need to # acknowledge receipt of the message to RabbitMQ. This acknowledgement # deletes it from the queue so the logic above must have saved or # handled the message before we get here. ch.basic_ack(delivery_tag=method.delivery_tag)
def ready(): """ This endpoint checks whether we can connect to the DataBC Geocoder """ test_address = "4350 STILL CREEK, CHILLIWACK" results = helper.middle_logic(business.determine_ready_status(), config=Config, address_raw=test_address) return results.get('response')
def ingest_form(): if request.method == 'POST': # invoke middleware functions args = helper.middle_logic(business.ingest_form(), writer=g.writer, form_parameters=available_parameters['form'], request=request, config=Config) return args.get('response')
def ingest_orbeon_form(): if request.method == 'POST': logging.info("ingest_form_deprecated() invoked: {} | {}".format( request.remote_addr, request.get_data())) args = helper.middle_logic(business.ingest_form(), writer=g.writer, form_parameters=available_parameters, request=request, config=Config) return args.get('response')
def create(form_type): """ Save a new form. The web_app uses this endpoint to lease a unique form_id for 30 days and save the user's name in the form table. This endpoint is not used to submit a new form. All payloads to this endpoint are ignored. """ if request.method == 'POST': logging.info("new {} form_id requested".format(form_type)) kwargs = helper.middle_logic( get_authorized_keycloak_user() + [{ "try": form_middleware.request_contains_a_payload, "fail": [ { "try": form_middleware.lease_a_form_id, "fail": [ { "try": splunk_middleware.insufficient_form_ids, "fail": [] }, { "try": splunk.log_to_splunk, "fail": [] }, { "try": http_responses.server_error_response, "fail": [] }, ] }, { "try": splunk_middleware.log_form_create, "fail": [] }, { "try": splunk.log_to_splunk, "fail": [] }, { "try": http_responses.successful_create_response, "fail": [] }, ] }, { "try": http_responses.bad_request_response, "fail": [] }], required_permission='forms-create', request=request, form_type=form_type, config=Config) return kwargs.get('response')
def show(prohibition_number): """ PayBC requests details on the item to be paid from this endpoint. """ if request.method == 'GET': logging.info("show() invoked: {} | {}".format(request.remote_addr, request.get_data())) args = helper.middle_logic(rules.generate_invoice(), prohibition_number=prohibition_number, config=Config) return args.get('response', jsonify({"error": args.get('error_string')}))
def address(): """ Lookup lat/lon of street address using DataBC. If the DataBC's confidence score is below threshold determined in the config, check the address against Google's API and return both results. """ if request.method == 'POST': # invoke middleware functions args = helper.middle_logic(business.geocode_address(), request=request, config=Config) return args.get('response')
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']