def _check_uac_qid_pair_located_in_welsh_ce_estab_cases(matching_rows, uac, value):
# checks ind qid type for CE Estab Welsh in Welsh case and then tests against passed rows
if uac['payload']['uac']['questionnaireId'][:2] == '23':
expected_welsh_line_ending = f"|{uac['payload']['uac']['uac']}|" \
f"{uac['payload']['uac']['questionnaireId']}|{value['line_ending']}"
matched = False
for row in matching_rows:
if row.endswith(expected_welsh_line_ending):
matched = True
test_helper.assertTrue(matched,
f'Could not find expected Welsh line ending {expected_welsh_line_ending}')
else:
expected_english_line_start = f"{uac['payload']['uac']['uac']}|" \
f"{uac['payload']['uac']['questionnaireId']}|"
matched = False
for row in matching_rows:
if row.startswith(expected_english_line_start):
matched = True
test_helper.assertTrue(matched,
f'Could not find expected English line starting '
f'{expected_english_line_start}')
def check_the_cases_via_case_api(context):
for row in context.bulk_address_updates:
actual_case = get_case_and_case_events_by_case_id(row['CASE_ID'])
# Check all the fields available in the case API are updated
test_helper.assertEqual(actual_case['estabType'], row['ESTAB_TYPE'])
test_helper.assertEqual(actual_case['oa'], row['OA'])
test_helper.assertEqual(actual_case['lsoa'], row['LSOA'])
test_helper.assertEqual(actual_case['msoa'], row['MSOA'])
test_helper.assertEqual(actual_case['lad'], row['LAD'])
test_helper.assertEqual(actual_case['latitude'], row['LATITUDE'])
test_helper.assertEqual(actual_case['longitude'], row['LONGITUDE'])
test_helper.assertTrue(actual_case['secureEstablishment'],
'Secure flag should be changed to true')
test_helper.assertEqual(actual_case['uprn'], row['UPRN'])
test_helper.assertEqual(actual_case['estabUprn'], row['ESTAB_UPRN'])
test_helper.assertEqual(actual_case['addressLine1'],
row['ADDRESS_LINE1'])
test_helper.assertEqual(actual_case['addressLine2'],
row['ADDRESS_LINE2'])
test_helper.assertEqual(actual_case['addressLine3'],
row['ADDRESS_LINE3'])
test_helper.assertEqual(actual_case['abpCode'], row['ABP_CODE'])
test_helper.assertEqual(actual_case['organisationName'],
row['ORGANISATION_NAME'])
test_helper.assertEqual(actual_case['postcode'], row['POSTCODE'])
test_helper.assertEqual(actual_case['townName'], row['TOWN_NAME'])
def undelivered_qm_published_to_gcp_pubsub(context):
context.first_case = context.case_created_events[0]['payload'][
'collectionCase']
questionnaire_id = context.uac_created_events[0]['payload']['uac'][
'questionnaireId']
_publish_qm_undelivered_mail(context, questionnaire_id=questionnaire_id)
test_helper.assertTrue(context.sent_to_gcp)
def check_uac_message_is_received(context):
context.messages_received = []
context.expected_message_received = False
start_listening_to_rabbit_queue(
Config.RABBITMQ_RH_OUTBOUND_UAC_QUEUE,
functools.partial(_uac_callback, context=context))
test_helper.assertTrue(context.expected_message_received)
def validate_ccs_qid_for_case_id(context):
response_json = get_ccs_qid_for_case_id(context.ccs_case['id'])
test_helper.assertEqual(
response_json['questionnaireId'][0:3], '713',
'CCS QID has incorrect questionnaire type or tranche ID')
test_helper.assertTrue(response_json['active'])
test_helper.assertEqual(
response_json['formType'], "H",
f'Expected FormType is "H" but got "{response_json["formType"]}"')
def receipt_ccs_offline_msg_published_to_gcp_pubsub(context):
context.first_case = context.ccs_case
# TODO: Other tests match on this key structure. Remove when we've settled on case API fields
context.first_case['survey'] = context.ccs_case['surveyType']
response = get_ccs_qid_for_case_id(context.ccs_case['id'])
_publish_object_finalize(context, questionnaire_id=response['questionnaireId'])
test_helper.assertTrue(context.sent_to_gcp)
def _validate_case(parsed_body):
test_helper.assertEqual('CENSUS',
parsed_body['payload']['collectionCase']['survey'])
actual_case_ref = parsed_body['payload']['collectionCase']['caseRef']
test_helper.assertEqual(10, len(actual_case_ref))
parse_datetime(parsed_body['payload']['collectionCase']['createdDateTime'])
parse_datetime(parsed_body['payload']['collectionCase']['lastUpdated'])
test_helper.assertTrue(luhn.verify(actual_case_ref))
def check_case_events(context):
response = requests.get(
f'{Config.CASE_API_CASE_URL}{context.first_case["id"]}',
params={'caseEvents': True})
test_helper.assertTrue(200 <= response.status_code <= 299,
'Get cases API call failed')
cases = response.json()
test_helper.assertTrue(
any(case_event['description'] == 'Fulfilment Request Received'
for case_event in cases['caseEvents']))
def new_addresses_sent_to_field_secureType_true(context):
context.messages_received = []
start_listening_to_rabbit_queue(Config.RABBITMQ_OUTBOUND_FIELD_QUEUE,
functools.partial(
store_all_msgs_in_context, context=context,
expected_msg_count=1))
field_msg = context.messages_received[0]
test_helper.assertEqual(field_msg['actionInstruction'], 'CREATE')
test_helper.assertTrue(field_msg['secureEstablishment'])
def receipt_msg_published_to_gcp_pubsub(context):
context.first_case = context.case_created_events[0]['payload']['collectionCase']
for uac in context.uac_created_events:
if uac['payload']['uac']['caseId'] == context.first_case['id']:
questionnaire_id = uac['payload']['uac']['questionnaireId']
break
else:
test_helper.fail('Could not find UAC_UPDATED event for receipted case')
_publish_object_finalize(context, questionnaire_id=questionnaire_id)
test_helper.assertTrue(context.sent_to_gcp)
def check_survey_launched_case_updated_events(context, case_ids):
context.messages_received = []
start_listening_to_rabbit_queue(
Config.RABBITMQ_RH_OUTBOUND_CASE_QUEUE,
functools.partial(store_all_msgs_in_context,
context=context,
expected_msg_count=len(case_ids),
type_filter='CASE_UPDATED'))
for message in context.messages_received:
test_helper.assertTrue(
message['payload']['collectionCase']['surveyLaunched'],
(f'Expected to find {len(case_ids)} CASE_UPDATED events as a result of survey launches '
f'found event with "surveyLaunched"=False, cases expected={case_ids}'
))
test_helper.assertIn(message['payload']['collectionCase']['id'],
case_ids, 'Found event for unexpected case')
def compare_case_and_uac(context, questionnaire_type, uac):
for caze in context.print_cases:
if caze['id'] == uac['payload']['uac']['caseId']:
test_helper.assertTrue(
uac['payload']['uac']['questionnaireId'].startswith(
questionnaire_type),
'Fulfilment request UAC updated event found with wrong questionnaire type'
)
context.requested_uac_and_qid.append({
'qid':
uac['payload']['uac']['questionnaireId'],
'uac':
uac['payload']['uac']['uac'],
'case':
caze
})
def check_address_invalid_case_updated_events(context):
address_invalid_case_ids = set(context.bulk_invalid_addresses.keys())
case_updated_events = get_case_updated_events(
context, len(address_invalid_case_ids))
test_helper.assertEqual(len(case_updated_events),
len(context.bulk_invalid_addresses))
for event in case_updated_events:
test_helper.assertTrue(
event['payload']['collectionCase']['addressInvalid'],
'Address invalid flag must be "True" on all updated events')
test_helper.assertIn(event['payload']['collectionCase']['id'],
address_invalid_case_ids,
'Unexpected case ID found on updated event')
context.bulk_invalid_address_file.unlink()
if Config.BULK_INVALID_ADDRESS_BUCKET_NAME:
clear_bucket(Config.BULK_INVALID_ADDRESS_BUCKET_NAME)
def check_new_cases_are_emitted(context):
test_helper.assertGreater(
len(context.bulk_new_addresses), 0,
'Must have at least one new address for this test to be valid')
context.case_created_events = get_case_created_events(
context, len(context.bulk_new_addresses))
test_helper.assertEqual(
len(context.case_created_events), len(context.bulk_new_addresses),
'Number of created cases should match number supplied in the bulk file'
)
for address in context.bulk_new_addresses:
test_helper.assertTrue(
any([
new_address_matches_case_created(address, case_created_event)
for case_created_event in context.case_created_events
]), f'No case created event found for address: {address}')
if Config.BULK_NEW_ADDRESS_BUCKET_NAME:
clear_bucket(Config.BULK_NEW_ADDRESS_BUCKET_NAME)
def new_addresses_sent_to_field(context):
expected_case_ids = [
event['payload']['collectionCase']['id']
for event in context.case_created_events
]
context.messages_received = []
start_listening_to_rabbit_queue(
Config.RABBITMQ_OUTBOUND_FIELD_QUEUE,
functools.partial(store_all_msgs_in_context,
context=context,
expected_msg_count=len(context.case_created_events)))
for field_msg in context.messages_received:
test_helper.assertEqual(field_msg['actionInstruction'], 'CREATE')
test_helper.assertTrue(field_msg['undeliveredAsAddress'])
for expected_case_id in expected_case_ids:
if field_msg['caseId'] == expected_case_id:
expected_case_ids.remove(expected_case_id)
break
test_helper.assertEqual(len(expected_case_ids), 0,
'Not all new addresses accounted for')
def gather_uac_updated_events(context, number_of_matching_cases,
questionnaire_type):
start_listening_to_rabbit_queue(
Config.RABBITMQ_RH_OUTBOUND_UAC_QUEUE,
functools.partial(
store_all_uac_updated_msgs_by_collection_exercise_id,
context=context,
expected_msg_count=int(number_of_matching_cases),
collection_exercise_id=context.collection_exercise_id))
test_helper.assertEqual(len(context.messages_received),
int(number_of_matching_cases))
context.reminder_uac_updated_events = context.messages_received.copy()
for uac_updated_event in context.reminder_uac_updated_events:
test_helper.assertTrue(
uac_updated_event['payload']['uac']['questionnaireId'].startswith(
questionnaire_type),
f"Exoected QIDs to have type {questionnaire_type}, "
f"found QID {uac_updated_event['payload']['uac']['questionnaireId']}"
)
context.reminder_case_ids = {
uac['payload']['uac']['caseId']
for uac in context.reminder_uac_updated_events
}
context.messages_received = []
def send_receipt_for_unaddressed(context):
_publish_offline_receipt(context, questionnaire_id=context.expected_questionnaire_id)
test_helper.assertTrue(context.sent_to_gcp)
def check_address_update_case_updated_events(context):
address_update_case_ids = set(row['CASE_ID']
for row in context.bulk_address_updates)
context.case_updated_events = get_case_updated_events(
context, len(address_update_case_ids))
test_helper.assertEqual(len(context.case_updated_events),
len(context.bulk_address_updates))
for event in context.case_updated_events:
collection_case = event['payload']['collectionCase']
test_helper.assertIn(collection_case['id'], address_update_case_ids,
'Unexpected case ID found on updated event')
test_helper.assertEqual(
collection_case['treatmentCode'],
context.bulk_address_updates[0]['TREATMENT_CODE'])
test_helper.assertEqual(collection_case['address']['estabType'],
context.bulk_address_updates[0]['ESTAB_TYPE'])
test_helper.assertEqual(collection_case['oa'],
context.bulk_address_updates[0]['OA'])
test_helper.assertEqual(collection_case['lsoa'],
context.bulk_address_updates[0]['LSOA'])
test_helper.assertEqual(collection_case['msoa'],
context.bulk_address_updates[0]['MSOA'])
test_helper.assertEqual(collection_case['lad'],
context.bulk_address_updates[0]['LAD'])
test_helper.assertEqual(
collection_case['fieldCoordinatorId'],
context.bulk_address_updates[0]['FIELDCOORDINATOR_ID'])
test_helper.assertEqual(
collection_case['fieldOfficerId'],
context.bulk_address_updates[0]['FIELDOFFICER_ID'])
test_helper.assertEqual(collection_case['address']['latitude'],
context.bulk_address_updates[0]['LATITUDE'])
test_helper.assertEqual(collection_case['address']['longitude'],
context.bulk_address_updates[0]['LONGITUDE'])
test_helper.assertTrue(
collection_case['metadata']['secureEstablishment'],
'Secure flag should be changed to true')
test_helper.assertEqual(collection_case['printBatch'],
context.bulk_address_updates[0]['PRINT_BATCH'])
test_helper.assertEqual(
collection_case['ceExpectedCapacity'],
int(context.bulk_address_updates[0]['CE_EXPECTED_CAPACITY']))
test_helper.assertEqual(
collection_case['htcWillingness'],
context.bulk_address_updates[0]['HTC_WILLINGNESS'])
test_helper.assertEqual(collection_case['htcDigital'],
context.bulk_address_updates[0]['HTC_DIGITAL'])
test_helper.assertEqual(collection_case['address']['uprn'],
context.bulk_address_updates[0]['UPRN'])
test_helper.assertEqual(collection_case['address']['estabUprn'],
context.bulk_address_updates[0]['ESTAB_UPRN'])
test_helper.assertEqual(
collection_case['address']['addressLine1'],
context.bulk_address_updates[0]['ADDRESS_LINE1'])
test_helper.assertEqual(
collection_case['address']['addressLine2'],
context.bulk_address_updates[0]['ADDRESS_LINE2'])
test_helper.assertEqual(
collection_case['address']['addressLine3'],
context.bulk_address_updates[0]['ADDRESS_LINE3'])
test_helper.assertEqual(collection_case['address']['abpCode'],
context.bulk_address_updates[0]['ABP_CODE'])
test_helper.assertEqual(
collection_case['address']['organisationName'],
context.bulk_address_updates[0]['ORGANISATION_NAME'])
test_helper.assertEqual(collection_case['address']['postcode'],
context.bulk_address_updates[0]['POSTCODE'])
test_helper.assertEqual(collection_case['address']['townName'],
context.bulk_address_updates[0]['TOWN_NAME'])
test_helper.assertFalse(
collection_case['skeleton'],
'Skeleton flag should be removed from updated case')
context.bulk_address_updates_file.unlink()
if Config.BULK_ADDRESS_UPDATE_BUCKET_NAME:
clear_bucket(Config.BULK_ADDRESS_UPDATE_BUCKET_NAME)
def offline_receipt_for_an_unlinked_qid(context):
_publish_offline_receipt(context, channel="QM", questionnaire_id=context.expected_questionnaire_id, unreceipt=True)
test_helper.assertTrue(context.sent_to_gcp)
def undelivered_unlinked_qm_published_to_gcp_pubsub(context):
_publish_qm_undelivered_mail(context,
questionnaire_id=context.requested_qid)
test_helper.assertTrue(context.sent_to_gcp)
test_helper.assertEqual('CENSUS', action_instruction['surveyName'])
test_helper.assertEqual(case['address']['estabType'],
action_instruction['estabType'])
test_helper.assertEquals(case['ceExpectedCapacity'],
int(action_instruction['ceExpectedCapacity']))
test_helper.assertEquals(case['ceActualResponses'],
int(action_instruction['ceActualResponses']))
test_helper.assertEquals(case['handDelivery'],
action_instruction['handDeliver'])
test_helper.assertEquals(case['caseRef'], action_instruction['caseRef'])
test_helper.assertEquals(len(action_instruction['caseRef']), 10)
test_helper.assertEquals(case['address']['uprn'],
action_instruction['uprn'])
test_helper.assertEquals(case['address']['estabUprn'],
action_instruction['estabUprn'])
test_helper.assertTrue(luhn.verify(action_instruction['caseRef']))
def field_work_cancel_callback(ch, method, _properties, body, context):
action_cancel = json.loads(body)
if not action_cancel['actionInstruction'] == 'CANCEL':
ch.basic_nack(delivery_tag=method.delivery_tag)
test_helper.fail(
f'Unexpected message on {Config.RABBITMQ_OUTBOUND_FIELD_QUEUE} case queue. '
f'Got "{action_cancel["actionInstruction"]}", wanted "CANCEL"')
context.addressType = action_cancel['addressType']
context.fwmt_emitted_case_id = action_cancel['caseId']
context.field_action_cancel_message = action_cancel
ch.basic_ack(delivery_tag=method.delivery_tag)
def receipt_offline_msg_published_to_gcp_pubsub(context):
context.first_case = context.case_created_events[0]['payload']['collectionCase']
questionnaire_id = context.uac_created_events[0]['payload']['uac']['questionnaireId']
_publish_offline_receipt(context, channel='PQRS', unreceipt=False, questionnaire_id=questionnaire_id)
test_helper.assertTrue(context.sent_to_gcp)
def continuation_receipt_offline_msg_published_to_gcp_pubsub(context):
_publish_offline_receipt(context, questionnaire_id=context.requested_qid)
test_helper.assertTrue(context.sent_to_gcp)
def blank_questionnaire_msg_published_to_gcp_pubsubs(context):
_publish_offline_receipt(context, channel="QM", questionnaire_id=context.qid_to_receipt, unreceipt=True)
test_helper.assertTrue(context.sent_to_gcp)
def send_receipt(context):
_publish_object_finalize(context, questionnaire_id=context.qid_to_receipt)
test_helper.assertTrue(context.sent_to_gcp)
def offline_msg_published_to_gcp_pubsub_for_unlinked_qids(context):
_publish_offline_receipt(context, channel='PQRS', unreceipt=False,
questionnaire_id=context.expected_questionnaire_id)
test_helper.assertTrue(context.sent_to_gcp)
def undelivered_ppo_published_to_gcp_pubsub(context):
context.first_case = context.case_created_events[0]['payload'][
'collectionCase']
case_ref = context.first_case['caseRef']
_publish_ppo_undelivered_mail(context, case_ref=case_ref)
test_helper.assertTrue(context.sent_to_gcp)
def check_census_case_fields(context):
test_helper.assertTrue(context.case_details['caseRef'])
test_helper.assertEquals(len(context.case_details['caseRef']), 10)
test_helper.assertTrue(luhn.verify(context.case_details['caseRef']))
test_helper.assertTrue(context.case_details['estabUprn'])
test_helper.assertTrue(context.case_details['estabType'])
test_helper.assertTrue(context.case_details['uprn'])
test_helper.assertTrue(context.case_details['collectionExerciseId'])
test_helper.assertTrue(context.case_details['createdDateTime'])
test_helper.assertTrue(context.case_details['lastUpdated'])
test_helper.assertTrue(context.case_details['addressLine1'])
test_helper.assertTrue(context.case_details['addressLine2'])
test_helper.assertTrue(context.case_details['addressLine3'])
test_helper.assertTrue(context.case_details['townName'])
test_helper.assertTrue(context.case_details['postcode'])
test_helper.assertTrue(context.case_details['addressLevel'])
test_helper.assertTrue(context.case_details['abpCode'])
test_helper.assertTrue(context.case_details['region'])
test_helper.assertTrue(context.case_details['latitude'])
test_helper.assertTrue(context.case_details['longitude'])
test_helper.assertTrue(context.case_details['oa'])
test_helper.assertTrue(context.case_details['lsoa'])
test_helper.assertTrue(context.case_details['msoa'])
test_helper.assertTrue(context.case_details['lad'])
test_helper.assertTrue(context.case_details['id'])
test_helper.assertTrue(context.case_details['addressType'])
test_helper.assertTrue(context.case_details['caseType'])
test_helper.assertEqual(context.case_details['surveyType'], "CENSUS")
test_helper.assertFalse(context.case_details['handDelivery'])
