def check_address_valid_case_updated_events(context):
address_valid_case_ids = [case_id['CASE_ID'] for case_id in context.bulk_uninvalidated_addresses]
context.case_updated_events = get_case_updated_events(context, len(address_valid_case_ids))
test_helper.assertEqual(len(context.case_updated_events), len(context.bulk_uninvalidated_addresses))
for event in context.case_updated_events:
test_helper.assertFalse(event['payload']['collectionCase']['addressInvalid'],
'Address invalid flag must be "False" on all updated events')
test_helper.assertIn(event['payload']['collectionCase']['id'], address_valid_case_ids,
'Unexpected case ID found on updated event')
def test_uacs_correct_for_estab_units(context, expected_uacs,
questionnaire_type):
questionnaire_types_list = questionnaire_type.replace('[', '').replace(
']', '').split(',')
test_helper.assertEqual(len(context.messages_received), expected_uacs)
for msg in context.uac_created_events:
_validate_uac_message(msg)
test_helper.assertIn(msg['payload']['uac']['questionnaireId'][:2],
questionnaire_types_list)
def check_for_bad_messages(context):
time.sleep(30)
response = requests.get(f'{Config.EXCEPTION_MANAGER_URL}/badmessages/summary')
bad_messages = response.json()
for bad_message in bad_messages:
test_helper.assertGreater(bad_message['seenCount'], 1,
msg=f'Seen count is not greater than 1, failed bad message summary: {bad_message}')
test_helper.assertIn(bad_message['messageHash'], context.message_hashes,
msg=f'Unknown bad message hash, message summary: {bad_message}')
def rops_get_case_details_page(context):
context.case_details = context.case_created_events[0]['payload'][
'collectionCase']
case_details_page_response = requests.get(
f'{Config.PROTOCOL}://{Config.ROPS_HOST}:{Config.ROPS_PORT}/case-details?case_id={context.first_case["id"]}'
)
case_details_page_response.raise_for_status()
context.case_details_text = case_details_page_response.text
test_helper.assertIn('Link QID', context.case_details_text)
def check_qid_link_confirmation_page(context):
qid_link_page = context.qid_link_response.text
test_helper.assertIn('Confirm linking this QID and Case ID', qid_link_page)
test_helper.assertIn(f'<b>QID:</b> {context.requested_qid}', qid_link_page)
test_helper.assertIn(f'<b>Case ID:</b> {context.case_details["id"]}',
qid_link_page)
test_helper.assertIn('Link QID', qid_link_page)
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 check_case_updated_event(context):
context.case_updated_events = get_case_updated_events(context, 1)
collection_case = context.case_updated_events[0]['payload']['collectionCase']
test_helper.assertIn(collection_case['id'], context.rm_case_updated['caseId'])
test_helper.assertEqual(collection_case['treatmentCode'], context.rm_case_updated['treatmentCode'])
test_helper.assertEqual(collection_case['address']['estabType'], context.rm_case_updated['estabType'])
test_helper.assertEqual(collection_case['oa'], context.rm_case_updated['oa'])
test_helper.assertEqual(collection_case['lsoa'], context.rm_case_updated['lsoa'])
test_helper.assertEqual(collection_case['msoa'], context.rm_case_updated['msoa'])
test_helper.assertEqual(collection_case['lad'], context.rm_case_updated['lad'])
test_helper.assertEqual(collection_case['fieldCoordinatorId'],
context.rm_case_updated['fieldCoordinatorId'])
test_helper.assertEqual(collection_case['fieldOfficerId'], context.rm_case_updated['fieldOfficerId'])
test_helper.assertEqual(collection_case['address']['latitude'], context.rm_case_updated['latitude'])
test_helper.assertEqual(collection_case['address']['longitude'], context.rm_case_updated['longitude'])
test_helper.assertFalse(collection_case['skeleton'], 'Skeleton flag should be removed from updated case')
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 deactivate_uac_events_logged_against_all_uac_qid_pairs(context):
for case in context.case_created_events:
actual_logged_events = get_logged_events_for_case_by_id(
case["payload"]["collectionCase"]["id"])
actual_logged_event_types = [
event['eventType'] for event in actual_logged_events
]
test_helper.assertIn(
'DEACTIVATE_UAC',
actual_logged_event_types,
msg=(f'Expected event type = {"DEACTIVATE_UAC"},'
f' actual logged event types = {actual_logged_event_types}'))
if hasattr(context, 'bulk_deactivate_uac_file'):
context.bulk_deactivate_uac_file.unlink()
if Config.BULK_DEACTIVATE_UAC_BUCKET_NAME:
clear_bucket(Config.BULK_DEACTIVATE_UAC_BUCKET_NAME)
def check_cases_are_updated_with_correct_refusal_types(context):
case_updated_events = get_case_updated_events(context,
len(context.bulk_refusals))
for event in case_updated_events:
test_helper.assertIn(
event['payload']['collectionCase']['id'],
context.bulk_refusals.keys(),
'Case updated events should only be emitted for refused cases')
expected_refusal_type = context.bulk_refusals[event['payload']
['collectionCase']['id']]
test_helper.assertEqual(
event['payload']['collectionCase']['refusalReceived'],
expected_refusal_type,
'Refusal type on the case updated events should match the expected type from the bulk file'
)
context.bulk_refusals_file.unlink()
if Config.BULK_REFUSAL_BUCKET_NAME:
clear_bucket(Config.BULK_REFUSAL_BUCKET_NAME)
def check_address_valid_case_updated_events(context):
address_valid_case_ids = [
case_id['CASE_ID'] for case_id in context.bulk_uninvalidated_addresses
]
context.case_updated_events = get_case_updated_events(
context, len(address_valid_case_ids))
test_helper.assertEqual(len(context.case_updated_events),
len(context.bulk_uninvalidated_addresses))
for event in context.case_updated_events:
test_helper.assertFalse(
event['payload']['collectionCase']['addressInvalid'],
'Address invalid flag must be "False" on all updated events')
test_helper.assertIn(event['payload']['collectionCase']['id'],
address_valid_case_ids,
'Unexpected case ID found on updated event')
context.bulk_uninvalidated_addresses_file.unlink()
if Config.BULK_UNINVALIDATED_ADDRESS_BUCKET_NAME:
clear_bucket(Config.BULK_UNINVALIDATED_ADDRESS_BUCKET_NAME)
def new_address_load_success_callback(db_result, timeout_deadline):
# Check we have the right number of cases and all the expected case ID's are present
if len(db_result) == len(context.bulk_new_addresses):
new_address_case_ids = {
case_created['payload']['collectionCase']['id']
for case_created in context.case_created_events
}
for case_id in (result[0] for result in db_result):
test_helper.assertIn(
case_id, new_address_case_ids,
f'Found case ID {case_id} in action plan {context.action_plan_id} '
f'with no matching created event from the new address bulk load'
)
return True
if time.time() > timeout_deadline:
test_helper.fail(
"Didn't find all new address cases in action database before the time out"
)
return False
def mark_cases_as_invalid(context):
invalid_address_case_ids = [
case['payload']['collectionCase']['id']
for case in context.case_created_events
]
for case_id in invalid_address_case_ids:
send_invalid_address_message_to_rabbit(case_id, "CC")
case_updated_events = get_case_updated_events(
context, len(context.case_created_events))
for event in case_updated_events:
test_helper.assertIn(event['payload']['collectionCase']['id'],
invalid_address_case_ids,
'Unexpected case ID found on updated event')
context.cancels_to_ignore = []
start_listening_to_rabbit_queue(
Config.RABBITMQ_OUTBOUND_FIELD_QUEUE,
functools.partial(ignore_field_cancel_msgs,
context=context,
expected_msg_count=len(case_updated_events)))
def rops_results(context):
sorted_cases = sorted(context.cases_by_postcode,
key=operator.itemgetter('organisationName',
'addressLine1', 'caseType',
'addressLevel'))
# Check the order returned by case API
test_helper.assertEqual(
context.cases_by_postcode, sorted_cases,
'The API should return the cases in the correct order')
# Check the expected data is on the page
postcode_result_text = context.postcode_result.text
test_helper.assertIn(
f'{context.number_of_cases} results for postcode: "{context.postcode}"',
postcode_result_text)
case_page_locations = []
for case in context.cases_by_postcode:
test_helper.assertIn(case['caseRef'], postcode_result_text)
test_helper.assertIn(case['addressLine1'], postcode_result_text)
test_helper.assertIn(case['uprn'], postcode_result_text)
test_helper.assertIn(case['estabType'], postcode_result_text)
case_page_locations.append({
'id':
case['id'],
'location':
postcode_result_text.find(case['caseRef'])
})
# Check the cases appear in the expected order on the page
case_order_on_page = [
case['id'] for case in sorted(case_page_locations,
key=operator.itemgetter('location'))
]
test_helper.assertEqual(
case_order_on_page, [case['id'] for case in sorted_cases],
'The order of cases should be in order on the page')
def rops_check_case_details_page(context):
test_helper.assertIn(context.case_details["caseRef"],
context.case_details_text)
test_helper.assertIn(context.case_details["address"]["addressLevel"],
context.case_details_text)
test_helper.assertIn(context.case_details["caseType"],
context.case_details_text)
test_helper.assertIn(str(context.case_details["skeleton"]),
context.case_details_text)
test_helper.assertIn(context.case_details["collectionExerciseId"],
context.case_details_text)
test_helper.assertIn(context.case_details["lsoa"],
context.case_details_text)
test_helper.assertNotIn("RM_UAC_CREATED", context.case_details_text)
def rops_get_CCS_case_details_page(context):
context.case_details = context.first_case
context.case_details_text = get_case_details_page(
context.first_case['id']).text
test_helper.assertIn('Link QID', context.case_details_text)
def rops_get_case_details_page(context):
context.case_details = context.case_created_events[0]['payload'][
'collectionCase']
context.case_details_text = get_case_details_page(
context.first_case['id']).text
test_helper.assertIn('Link QID', context.case_details_text)
def qid_details_page(context):
response_text = context.qid_link_response.text
test_helper.assertIn(f'<b>QID:</b> {context.requested_qid}', response_text)
def linking_non_ccs_qid_to_ccs_case_forbidden_message(context):
response_text = context.qid_link_response.text
test_helper.assertIn('Linking a non CCS QID to a CCS case is forbidden',
response_text)
def qid_failed_message(context):
response_text = context.qid_link_response.text
test_helper.assertIn('QID does not exist in RM', response_text)
def qid_linked_message_appears(context):
response_text = context.qid_link_response.text
test_helper.assertIn('QID link has been submitted', response_text)
def search_for_fake_qid(context):
test_helper.assertIn('Link QID', context.case_details_text)
context.qid_link_response = get_rops_qid_link_page(
case_id=context.case_details['id'], qid='nonsense')
test_helper.assertEqual(context.qid_link_response.status_code, 200)
def rops_home_page(context):
home_page_response = requests.get(
f'{Config.PROTOCOL}://{Config.ROPS_HOST}:{Config.ROPS_PORT}')
home_page_response.raise_for_status()
home_text = home_page_response.text
test_helper.assertIn('Enter a postcode', home_text)
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 submit_qid_link_on_r_ops(context):
test_helper.assertIn('Link QID', context.case_details_text)
context.qid_link_response = submit_rops_qid_link(
case_id=context.case_details['id'], qid=context.requested_qid)
test_helper.assertEqual(context.qid_link_response.status_code, 200)
