def test_consent_get_with_consent(self): # Pre-Req Utils.send_consent_post(self.token) # Given expected_status_code = 200 # When response = requests.get( url=config.REASONABLE_ADJUSTMENTS_CONSENT, params={ 'patient': config.TEST_PATIENT_NHS_NUMBER, 'category': 'https://fhir.nhs.uk/STU3/CodeSystem/RARecord-FlagCategory-1|NRAF', 'status': 'active', '_from': 'json' }, headers={ 'Authorization': f'Bearer {self.token}', 'nhsd-session-urid': config.TEST_NHSD_SESSION_URID, 'x-request-id': str(uuid.uuid4()), 'Accept': 'application/fhir+json' } ) # Then result_dict = json.loads(response.text) assert_that(expected_status_code).is_equal_to(response.status_code) assert_that(result_dict['total']).is_equal_to(1) # Validate patient record contains a consent flag
def setup(request): """This function is called before each test is executed""" # Get the name of the current test and attach it the the test instance name = (request.node.name, request.node.originalname)[request.node.originalname is not None] setattr(request.cls, "name", name) yield # Handover to test time.sleep(1) # Teardown # Return patient to previous state if hasattr(request.cls, 'token'): # Call this regardless whether any flags exist Utils.send_raremoverecord_post(request.cls.token) try: # Close any lingering sessions request.cls.test.session.close() except AttributeError: # Probably failed during setup # so nothing to teardown pass
def test_list_put(self): # Pre-Req Utils.send_consent_post(self.token) Utils.send_list_post(self.token) get_list_response = Utils.send_list_get(self.token) list_id = get_list_response['id'] version_id = get_list_response['version'] # Given expected_status_code = 200 req_body = request_bank.get_body(Request.LIST_PUT) req_body['id'] = list_id # When response = requests.put( url=config.REASONABLE_ADJUSTMENTS_LIST + '/' + list_id, headers={ 'Authorization': f'Bearer {self.token}', 'nhsd-session-urid': config.TEST_NHSD_SESSION_URID, 'x-request-id': str(uuid.uuid4()), 'content-type': 'application/fhir+json', 'accept': 'application/fhir+json', 'if-match': version_id, }, data=json.dumps(req_body) ) # Then assert_that(expected_status_code).is_equal_to(response.status_code)
def test_flag_put(self): # Pre-Req: Patient has both a consent and flag Utils.send_consent_post(self.token) Utils.send_flag_post(self.token) get_flag_response = Utils.send_flag_get(self.token) # Given expected_status_code = 200 flag_id = get_flag_response['id'] version_id = get_flag_response['version'] # When response = requests.put( url=config.REASONABLE_ADJUSTMENTS_FLAG + '/' + flag_id, headers={ 'Authorization': f'Bearer {self.token}', 'nhsd-session-urid': config.TEST_NHSD_SESSION_URID, 'x-request-id': str(uuid.uuid4()), 'content-type': 'application/fhir+json', 'Accept': 'application/fhir+json', 'If-match': version_id, }, json=request_bank.get_body(Request.FLAG_PUT) ) # Then assert_that(expected_status_code).is_equal_to(response.status_code)
def test_consent_put(self): # Pre-Req Utils.send_consent_post(self.token) # Given expected_status_code = 200 # And consent = Utils.send_consent_get(self.token) consent_id = consent['id'] version_id = consent['version'] # When response = requests.put( url=config.REASONABLE_ADJUSTMENTS_CONSENT + '/' + consent_id, json=request_bank.get_body(Request.CONSENT_PUT), headers={ 'Authorization': f'Bearer {self.token}', 'nhsd-session-urid': config.TEST_NHSD_SESSION_URID, 'x-request-id': str(uuid.uuid4()), 'content-type': 'application/fhir+json', 'If-Match': version_id } ) # Then assert_that(expected_status_code).is_equal_to(response.status_code)
def test_valid_ods(self): # Given debug_session = ApigeeDebugApi(REASONABLE_ADJUSTMENTS_PROXY_NAME) expected_ods = 'D82106' # When Utils.send_request(self) # Then actual_ods = debug_session.get_apigee_variable( 'verifyapikey.VerifyAPIKey.CustomAttributes.ods') assert_that(expected_ods).is_equal_to(actual_ods)
def test_x_request_id_equals_nhsd_request_id(self): # Given debug_session = ApigeeDebugApi( config.REASONABLE_ADJUSTMENTS_PROXY_NAME) # When Utils.send_request(self) # Then trace_id = debug_session.get_apigee_header('NHSD-Request-ID') x_request_id = debug_session.get_apigee_header('x-request-id') assert_that(trace_id).is_equal_to(x_request_id)
def test_jwt(self): # Given debug_session = ApigeeDebugApi(REASONABLE_ADJUSTMENTS_PROXY_NAME) expected_jwt_claims = { 'reason_for_request': 'directcare', 'scope': 'user/Consent.read', 'requesting_organization': 'https://fhir.nhs.uk/Id/ods-organization-code|D82106', 'requesting_system': 'https://fhir.nhs.uk/Id/accredited-system|200000001390', 'requesting_user': f'https://fhir.nhs.uk/Id/sds-role-profile-id|{config.TEST_NHSD_SESSION_URID}', 'sub': f'https://fhir.nhs.uk/Id/sds-role-profile-id|{config.TEST_NHSD_SESSION_URID}', 'iss': 'http://api.service.nhs.uk', 'aud': f'/{REASONABLE_ADJUSTMENTS_PROXY_PATH}/Consent' } # When Utils.send_request(self) # Then # We should pull Authorization header instead but Apigee mask that value so we get spineJwt variable instead actual_jwt = debug_session.get_apigee_variable('spineJwt') # We manually decode jwt because, jwt library requires all three segments but we only have two (no signature). jwt_segments = actual_jwt.split('.') actual_jwt_claims = json.loads(base64.b64decode(jwt_segments[1])) assert_that(expected_jwt_claims['reason_for_request'] ).is_equal_to_ignoring_case( actual_jwt_claims['reason_for_request']) assert_that(expected_jwt_claims['scope']).is_equal_to_ignoring_case( actual_jwt_claims['scope']) assert_that(expected_jwt_claims['requesting_organization'] ).is_equal_to_ignoring_case( actual_jwt_claims['requesting_organization']) assert_that(expected_jwt_claims['requesting_system'] ).is_equal_to_ignoring_case( actual_jwt_claims['requesting_system']) assert_that( expected_jwt_claims['requesting_user']).is_equal_to_ignoring_case( actual_jwt_claims['requesting_user']) assert_that(expected_jwt_claims['sub']).is_equal_to_ignoring_case( actual_jwt_claims['sub']) assert_that(expected_jwt_claims['iss']).is_equal_to_ignoring_case( actual_jwt_claims['iss']) assert_that(expected_jwt_claims['aud']).is_equal_to_ignoring_case( actual_jwt_claims['aud'])
def test_ASID_fetch(self): # Given debug_session = ApigeeDebugApi( config.REASONABLE_ADJUSTMENTS_PROXY_NAME) expected_value = '200000001390' # When Utils.send_request(self) # Then actual_asid = debug_session.get_apigee_variable( 'verifyapikey.VerifyAPIKey.CustomAttributes.asid') assert_that(expected_value).is_equal_to(actual_asid) actual_header_value = debug_session.get_apigee_header('NHSD-ASID') assert_that(expected_value).is_equal_to(actual_header_value)
def test_outgoing_request_contains_nhsd_correlation_id_header(self): # Given debug_session = ApigeeDebugApi( config.REASONABLE_ADJUSTMENTS_PROXY_NAME) # When Utils.send_request(self) # Then apigee_message_id = debug_session.get_apigee_variable('messageid') x_correlation_id_header = debug_session.get_apigee_header( 'x-correlation-id') x_request_id_header = debug_session.get_apigee_header('x-request-id') nhsd_correlation_id_header = debug_session.get_apigee_header( 'NHSD-Correlation-ID') expected_correlation_id_header = x_request_id_header + '.' + x_correlation_id_header + '.' + apigee_message_id assert_that(expected_correlation_id_header).is_equal_to( nhsd_correlation_id_header)
def test_remove_ra_record_post(self): # Pre_Req : Patient record with a consent Utils.send_consent_post(self.token) # Given expected_status_code = 200 # When response = requests.post( url=config.REASONABLE_ADJUSTMENTS_REMOVE_RA_RECORD, headers={ 'Authorization': f'Bearer {self.token}', 'nhsd-session-urid': config.TEST_NHSD_SESSION_URID, 'x-request-id': str(uuid.uuid4()), 'content-type': 'application/fhir+json', 'If-Match': 'W/"1"' }, json=request_bank.get_body(Request.REMOVE_RA_RECORD_POST)) # Then assert_that(expected_status_code).is_equal_to(response.status_code)
def test_list_post(self): # Pre-Req - Patient has consent Utils.send_consent_post(self.token) # Given expected_status_code = 201 # When response = requests.post(url=config.REASONABLE_ADJUSTMENTS_LIST, headers={ 'Authorization': f'Bearer {self.token}', 'nhsd-session-urid': config.TEST_NHSD_SESSION_URID, 'x-request-id': str(uuid.uuid4()), 'content-type': 'application/fhir+json', 'Accept': 'application/fhir+json' }, json=request_bank.get_body(Request.LIST_POST)) # Then assert_that(expected_status_code).is_equal_to(response.status_code)
def test_missing_asid(self): # Given expected_status_code = 500 expected_response = { 'resourceType': 'OperationOutcome', 'issue': [{ 'severity': 'error', 'code': 'value', 'details': { 'coding': [{ 'system': 'https://fhir.nhs.uk/R4/CodeSystem/Spine-ErrorOrWarningCode', 'version': '1', 'code': 'INTERNAL_SERVER_ERROR', 'display': 'Unexpected internal server error' }] }, 'diagnostics': 'An internal server error occurred. Missing ASID. Contact us for assistance diagnosing this issue: https://digital.nhs.uk/developer/help-and-support quoting Message ID' }] } # When response = Utils.send_request(self) actual_response = json.loads(response.text) # Then assert_that(expected_status_code).is_equal_to(response.status_code) # assert_that(actual_response['message_id']).is_not_empty() assert_that( expected_response['resourceType']).is_equal_to_ignoring_case( actual_response['resourceType']) assert_that( expected_response['issue'][0]['code']).is_equal_to_ignoring_case( actual_response['issue'][0]['code']) assert_that( expected_response['issue'][0]['details']['coding'][0] ['code']).is_equal_to_ignoring_case( actual_response['issue'][0]['details']['coding'][0]['code']) assert_that( expected_response['issue'][0]['details']['coding'][0] ['display']).is_equal_to_ignoring_case( actual_response['issue'][0]['details']['coding'][0]['display']) assert_that(expected_response['issue'][0] ['diagnostics']).is_equal_to_ignoring_case( actual_response['issue'][0]['diagnostics'])
def test_duplicate_consent_record(self): # Pre-Req Utils.send_consent_post(self.token) # Given expected_status_code = 422 # When response = requests.post(url=config.REASONABLE_ADJUSTMENTS_CONSENT, json=request_bank.get_body( Request.CONSENT_POST), headers={ 'Authorization': f'Bearer {self.token}', 'nhsd-session-urid': '093895563513', 'x-request-id': str(uuid.uuid4()), 'content-type': 'application/fhir+json', 'Accept': 'application/fhir+json' }) response_body = json.loads(response.text) # Then assert_that(expected_status_code).is_equal_to(response.status_code) assert_that('duplicate').is_equal_to(response_body['issue'][0]['code'])
def test_missing_ods(self): # Given expected_status_code = 500 expected_response = { 'error': 'missing ODS', 'error_description': 'An internal server error occurred. Missing ODS. Contact us for assistance diagnosing this issue: https://digital.nhs.uk/developer/help-and-support quoting Message ID', } # When response = Utils.send_request(self) actual_response = json.loads(response.text) # Then assert_that(expected_status_code).is_equal_to(response.status_code) assert_that(actual_response['message_id']).is_not_empty() assert_that(expected_response['error']).is_equal_to_ignoring_case( actual_response['error']) assert_that( expected_response['error_description']).is_equal_to_ignoring_case( actual_response['error_description'])