def test_get_interview_questions_randomised_ok(self): self.clear_interview_tasks_table() test_it = InterviewTask( **test_interview_tasks.interview_task_random_questions) test_it.ddb_dump() path_parameters = { "id": test_interview_tasks. interview_task_random_questions["live_survey_id"] } expected_status = HTTPStatus.OK result_1 = test_utils.test_get( ep.get_interview_questions_api, self.interview_questions_endpoint, path_parameters=path_parameters, ) result_1_status = result_1["statusCode"] result_1_body = json.loads(result_1["body"]) self.assertEqual(expected_status, result_1_status) result_2 = test_utils.test_get( ep.get_interview_questions_api, self.interview_questions_endpoint, path_parameters=path_parameters, ) result_2_status = result_2["statusCode"] result_2_body = json.loads(result_2["body"]) self.assertEqual(expected_status, result_2_status) self.assertNotEqual(result_1_body, result_2_body) self.assertCountEqual(result_1_body, result_2_body)
def test_user_a_project_status_project_order_include_non_visible(self): user_id = "d1070e81-557e-40eb-a7ba-b951ddb7ebdc" # [email protected] expected_project_order = [ "PSFU-02-pub-tst-ngrp", "PSFU-03-pub-tst-grp", "PSFU-04-prv-tst-grp", "CTG Monitoring", "PSFU-05-pub-act", "PSFU-06-prv-act", "PSFU-07-pub-comp", "PSFU-08-prv-comp", ] response = test_get( get_project_status_for_user_api, f"v1/{ENTITY_BASE_URL}", None, { "user_id": user_id, "include_non_visible_data": "true", }, None, ) result_json = json.loads(response["body"]) returned_project_order = [p["name"] for p in result_json] self.assertEqual(expected_project_order, returned_project_order)
def test_get_task_response_api_thisinstitute_account_ok(self): query_parameters = { "survey_id": "SV_ezK42q9nZRtRCxU", "response_id": "R_2pVHAWjO0XFfULI", "account": "thisinstitute", "anon_project_specific_user_id": "29aca87c-e0f9-44c2-b97e-22cbe842a908", } expected_status = HTTPStatus.OK result = test_tools.test_get( resp.get_task_response, self.entity_base_url, querystring_parameters=query_parameters, ) result_status = result["statusCode"] result_json = json.loads(result["body"]) # test results returned from api call self.assertEqual(expected_status, result_status) self.assertDictEqual( { "age": "2", "food": "[1, 3]", "job": "Quality Assurance Engineer" }, result_json, )
def test_1_list_projects_api(self): expected_status = HTTPStatus.OK expected_body = [ json.loads(x) for x in [ PROJECT_01_JSON, PROJECT_02_JSON, PROJECT_03_JSON, PROJECT_10_JSON, PROJECT_11_JSON, PROJECT_12_JSON, PROJECT_08_JSON, PROJECT_04_JSON, PROJECT_05_JSON, PROJECT_13_JSON, PROJECT_14_JSON, PROJECT_17_JSON, PROJECT_06_JSON, PROJECT_07_JSON, PROJECT_15_JSON, PROJECT_16_JSON, ] ] result = test_get(p.list_projects_api, f"v1/{ENTITY_BASE_URL}", None, None, None) result_status = result["statusCode"] result_json = json.loads(result["body"]) self.assertEqual(expected_status, result_status) self.assertEqual(len(expected_body), len(result_json)) for (result, expected) in zip(result_json, expected_body): self.assertDictEqual(expected, result)
def test_get_interview_questions_randomised_config_conflict_raises_error( self): self.clear_interview_tasks_table() test_it = InterviewTask( **test_interview_tasks.interview_task_random_questions) test_it.ddb_dump() test_it_config_conflict = InterviewTask( **test_interview_tasks. interview_task_random_questions_config_conflict) test_it_config_conflict.ddb_dump() path_parameters = { "id": test_interview_tasks. interview_task_random_questions["live_survey_id"] } expected_status = HTTPStatus.INTERNAL_SERVER_ERROR result = test_utils.test_get( ep.get_interview_questions_api, self.interview_questions_endpoint, path_parameters=path_parameters, ) result_status = result["statusCode"] result_body = result["body"] self.assertEqual(expected_status, result_status) self.assertIn("Conflicting interview task configuration(s)", result_body)
def test_user_specific_task_url_ok(self): result = test_get( get_project_status_for_user_api, f"v1/{ENTITY_BASE_URL}", querystring_parameters={"user_id": self.user_id}, ) expected_status = HTTPStatus.OK result_status = result["statusCode"] self.assertEqual(expected_status, result_status) result_json = json.loads(result["body"]) expected_task_results = { "4ee70544-6797-4e21-8cec-5653c8d5b234": { "url": f"www.specific-user-task.co.uk" f"?anon_project_specific_user_id=e132c198-06d3-4200-a6c0-cc3bc7991828" f"&anon_user_task_id=47e98896-33b4-4401-b667-da95db9122a2" f"&project_task_id=4ee70544-6797-4e21-8cec-5653c8d5b234" f"&external_task_id=5678" f"&env={TEST_ENV}", } } for project in result_json: for task in project["tasks"]: expected_fields = expected_task_results.get(task["id"]) if expected_fields: for k, v in expected_fields.items(): self.assertEqual(v, task[k])
def test_21_users_demo_flag_ok(self): # todo: add new user(s) to test_data with distinct combinations of these flags expected_results = [ { "user_id": "851f7b34-f76c-49de-a382-7e4089b744e2", # [email protected] "has_demo_project": True, "has_live_project": True, }, { "user_id": "8518c7ed-1df4-45e9-8dc4-d49b57ae0663", # [email protected] "has_demo_project": True, "has_live_project": True, }, ] for expected_result in expected_results: path_parameters = {"id": expected_result["user_id"]} expected_status = HTTPStatus.OK result = test_get( get_user_by_id_api, ENTITY_BASE_URL, path_parameters=path_parameters ) result_status = result["statusCode"] result_json = json.loads(result["body"]) # test results returned from api call self.assertEqual(expected_status, result_status) for flag in ["has_demo_project", "has_live_project"]: self.assertEqual(expected_result[flag], result_json[flag])
def test_10_list_users_by_project_ok(self): project_id = "183c23a1-76a7-46c3-8277-501f0740939d" # PSFU 7 expected_users = [ { "anon_project_specific_user_id": "1406c523-6d12-4510-a745-271ddd9ad3e2", "email": "*****@*****.**", "first_name": "Eddie", "last_name": "Eagleton", "project_id": "183c23a1-76a7-46c3-8277-501f0740939d", "user_id": "1cbe9aad-b29f-46b5-920e-b4c496d42515", }, { "anon_project_specific_user_id": "2c8bba57-58a9-4ac7-98e8-beb34f0692c1", "email": "*****@*****.**", "first_name": "Altha", "last_name": "Alcorn", "project_id": "183c23a1-76a7-46c3-8277-501f0740939d", "user_id": "d1070e81-557e-40eb-a7ba-b951ddb7ebdc", }, { "anon_project_specific_user_id": "82ca200e-66d6-455d-95bc-617f974bcb26", "email": "*****@*****.**", "first_name": "Clive", "last_name": "Cresswell", "project_id": "183c23a1-76a7-46c3-8277-501f0740939d", "user_id": "8518c7ed-1df4-45e9-8dc4-d49b57ae0663", }, ] result = test_get( local_method=u.list_users_by_project_api, aws_url="v1/list-project-users", querystring_parameters={"project_id": project_id}, ) users = json.loads(result["body"]) self.assertCountEqual(expected_users, users)
def test_get_task_response_api_ok(self): query_parameters = { "survey_id": "SV_aWDwvBuOqAsxrkq", "response_id": "R_2VptOho22NGPmoe", "account": "cambridge", "anon_project_specific_user_id": "29aca87c-e0f9-44c2-b97e-22cbe842a908", } expected_status = HTTPStatus.OK result = test_tools.test_get( resp.get_task_response, self.entity_base_url, querystring_parameters=query_parameters, ) result_status = result["statusCode"] result_json = json.loads(result["body"]) # test results returned from api call self.assertEqual(expected_status, result_status) self.assertDictEqual( { "age": "2", "food": "[1, 3]", "job": "Quality Assurance Engineer" }, result_json, )
def test_ep_01_retrieve_response_api_ok(self): params = { "survey_id": self.test_survey_id, "response_id": self.test_response_id, "question_ids": json.dumps(self.test_question_ids), } result = test_utils.test_get( local_method=ep.retrieve_responses_api, aws_url=self.retrieve_responses_endpoint, querystring_parameters=params, ) self.assertEqual(HTTPStatus.OK, result["statusCode"]) expected_result_body = { "Q12_1": 1, "Q12_2": 1, "Q12_3": 1, "Q12_4": 1, "Q12_5": 1, "Q12_6": 1, "Q12_7": 1, "Q12_8": 1, "Q1": 1, "Q1COM": "Good job.", "Q12_8_TEXT": "Smoke signals", "Q4": None, "Q4COM": None, } pprint(json.loads(result["body"])) self.assertCountEqual(expected_result_body, json.loads(result["body"]))
def test_get_interview_questions_randomised_missing_config_interpreted_as_not_random( self, ): """ Interview Tasks without randomisation config are treated as specifying randomisation=False This also ensure backwards compatibility with existing InterviewTask objects. """ self.clear_interview_tasks_table() test_it = InterviewTask(**test_interview_tasks.interview_task_2) # use put_item instead of InterviewTask.ddb_dump to ensure item does not have random config self.ddb_client.put_item( table_name=const.INTERVIEW_TASKS_TABLE["name"], key=str(test_it._project_task_id), item_type="interview_task", item_details=None, item=test_interview_tasks.interview_task_2, key_name=const.INTERVIEW_TASKS_TABLE["partition_key"], sort_key={ const.INTERVIEW_TASKS_TABLE["sort_key"]: test_it._interview_task_id }, ) path_parameters = { "id": test_interview_tasks.interview_task_2["live_survey_id"] } expected_status = HTTPStatus.OK result_1 = test_utils.test_get( ep.get_interview_questions_api, self.interview_questions_endpoint, path_parameters=path_parameters, ) result_1_status = result_1["statusCode"] result_1_body = json.loads(result_1["body"]) self.assertEqual(expected_status, result_1_status) result_2 = test_utils.test_get( ep.get_interview_questions_api, self.interview_questions_endpoint, path_parameters=path_parameters, ) result_2_status = result_2["statusCode"] result_2_body = json.loads(result_2["body"]) self.assertEqual(expected_status, result_2_status) self.assertEqual(result_1_body, result_2_body)
def test_get_interview_task_not_found(self): path_parameters = {"id": td.ARBITRARY_UUID} expected_status = HTTPStatus.NOT_FOUND result = test_utils.test_get( ep.get_interview_task_api, self.entity_base_url, path_parameters=path_parameters, ) result_status = result["statusCode"] self.assertEqual(expected_status, result_status)
def test_get_interview_questions_not_found(self): path_parameters = {"id": "SV_NonExistent1234"} expected_status = HTTPStatus.NOT_FOUND result = test_utils.test_get( ep.get_interview_questions_api, self.interview_questions_endpoint, path_parameters=path_parameters, ) result_status = result["statusCode"] self.assertEqual(expected_status, result_status)
def test_patch_user_api_with_spaces_in_name_ok(self): user_id = "851f7b34-f76c-49de-a382-7e4089b744e2" expected_status = HTTPStatus.NO_CONTENT user_jsonpatch = [ {"op": "replace", "path": "/title", "value": "Sir"}, {"op": "replace", "path": "/first_name", "value": " Antônio"}, {"op": "replace", "path": "/last_name", "value": "Jobim "}, {"op": "replace", "path": "/email", "value": "*****@*****.**"}, {"op": "replace", "path": "/auth0_id", "value": "new-auth0-id"}, {"op": "replace", "path": "/status", "value": "singing"}, {"op": "replace", "path": "/country_code", "value": "BR"}, ] body = json.dumps(user_jsonpatch) path_parameters = {"id": user_id} result = test_patch( patch_user_api, ENTITY_BASE_URL, path_parameters=path_parameters, request_body=body, ) result_status = result["statusCode"] self.assertEqual(expected_status, result_status) # now check database values... path_parameters = {"id": user_id} expected_body = { "id": user_id, "email": "*****@*****.**", "title": "Sir", "first_name": "Antônio", "last_name": "Jobim", "auth0_id": "new-auth0-id", "country_code": "BR", "country_name": "Brazil", "crm_id": None, "avatar_string": "AJ", "status": "singing", } result = test_get( u.get_user_by_id_api, ENTITY_BASE_URL, path_parameters=path_parameters ) result_json = json.loads(result["body"]) for ignored_attribute in [ "created", "modified", "has_demo_project", "has_live_project", ]: result_json.pop(ignored_attribute, None) expected_body.pop(ignored_attribute, None) self.assertEqual(expected_body, result_json)
def test_project_status_invalid_user_id(self): user_id = "d1070e81-557e-40eb-a7ba-b951ddb7ebd" querystring_parameters = {"user_id": user_id} result = test_get( get_project_status_for_user_api, f"v1/{ENTITY_BASE_URL}", None, querystring_parameters, None, ) expected_status = HTTPStatus.BAD_REQUEST self.assertEqual(expected_status, result["statusCode"])
def test_project_status_nonexistent_user(self): user_id = "35224bd5-f8a8-41f6-8502-f96e12d6dddf" querystring_parameters = {"user_id": user_id} result = test_get( get_project_status_for_user_api, f"v1/{ENTITY_BASE_URL}", None, querystring_parameters, None, ) expected_status = HTTPStatus.NOT_FOUND self.assertEqual(expected_status, result["statusCode"])
def test_01_get_appointment_by_type_api_ok(self): body = json.dumps( {"type_ids": [str(td["dev_appointment_no_link_type_id"])]}) result = test_utils.test_get( local_method=abt.get_appointments_by_type_api, aws_url=self.endpoint_url, request_body=body, ) self.assertEqual(HTTPStatus.OK, result["statusCode"]) appointments = json.loads(result["body"])["appointments"] self.assertEqual(3, len(appointments))
def test_get_personal_link_api_missing_mandatory_data(self): params = { "survey_id": self.default_survey_id, "account": self.default_account, } expected_status = HTTPStatus.BAD_REQUEST result = test_utils.test_get( pl.get_personal_link_api, self.entity_base_url, querystring_parameters=params, ) self.assertEqual(expected_status, result["statusCode"])
def test_get_user_interview_task_does_not_exist(self): path_parameters = { "id": td.TEST_USER_INTERVIEW_TASK["response_id"].replace("2", "3") } expected_status = HTTPStatus.NOT_FOUND result = test_utils.test_get( ep.get_user_interview_task_api, self.entity_base_url, path_parameters=path_parameters, ) result_status = result["statusCode"] self.assertEqual(expected_status, result_status)
def test_01b_list_user_tasks_api_ok_interview_task(self): expected_status = HTTPStatus.OK expected_body = USER_TASK_03_EXPECTED_BODY querystring_parameters = { "user_id": "e067ed7b-bc98-454f-9c5e-573e2da5705c" } result = test_get(list_user_tasks_api, ENTITY_BASE_URL, None, querystring_parameters, None) result_status = result["statusCode"] result_json = json.loads(result["body"]) self.assertEqual(expected_status, result_status) self.assertDictEqual(expected_body, result_json)
def test_03_list_user_projects_api_no_results(self): expected_status = HTTPStatus.OK expected_body = [] querystring_parameters = {"user_id": "dceac123-03a7-4e29-ab5a-739e347b374d"} result = test_get( list_user_projects_api, ENTITY_BASE_URL, None, querystring_parameters, None ) result_status = result["statusCode"] result_json = json.loads(result["body"]) self.assertEqual(expected_status, result_status) self.assertEqual(expected_body, result_json)
def test_04_get_user_by_email_api_takes_one_and_only_one_querystring_parameter( self, ): expected_status = HTTPStatus.BAD_REQUEST result = test_get( u.get_user_by_email_api, ENTITY_BASE_URL, querystring_parameters={} ) result_status = result["statusCode"] result_json = json.loads(result["body"]) self.assertEqual(expected_status, result_status) self.assertTrue("correlation_id" in result_json) self.assertTrue( ("message" in result_json) and ( "This endpoint requires one query parameter (email or anon_project_specific_user_id); none were found" in result_json["message"] ) ) query_parameters = { "anon_project_specific_user_id": "2c8bba57-58a9-4ac7-98e8-beb34f0692c1", "email": "*****@*****.**", } result = test_get( u.get_user_by_email_api, ENTITY_BASE_URL, querystring_parameters=query_parameters, ) result_status = result["statusCode"] result_json = json.loads(result["body"]) self.assertEqual(expected_status, result_status) self.assertTrue("correlation_id" in result_json) self.assertTrue( ("message" in result_json) and ( "Please query by either email or anon_project_specific_user_id, but not both" in result_json["message"] ) )
def test_01_list_user_projects_api_ok(self): expected_status = HTTPStatus.OK expected_body = [USER_PROJECT_01_EXPECTED_BODY, USER_PROJECT_02_EXPECTED_BODY] querystring_parameters = {"user_id": "851f7b34-f76c-49de-a382-7e4089b744e2"} result = test_get( list_user_projects_api, ENTITY_BASE_URL, None, querystring_parameters, None ) result_status = result["statusCode"] result_json = json.loads(result["body"]) self.assertEqual(expected_status, result_status) self.assertDictEqual(expected_body[0], result_json[0])
def test_get_interview_task_ok(self): path_parameters = {"id": td.TEST_INTERVIEW_TASK["interview_task_id"]} expected_status = HTTPStatus.OK result = test_utils.test_get( ep.get_interview_task_api, self.entity_base_url, path_parameters=path_parameters, ) result_status = result["statusCode"] result_body = json.loads(result["body"]) del result_body["modified"] self.assertEqual(expected_status, result_status) self.assertEqual(td.TEST_INTERVIEW_TASK, result_body)
def test_response_includes_all_expected_attributes(self): user_id = "8518c7ed-1df4-45e9-8dc4-d49b57ae0663" querystring_parameters = {"user_id": user_id} response = test_get( get_project_status_for_user_api, f"v1/{ENTITY_BASE_URL}", None, querystring_parameters, None, ) result = json.loads(response["body"]) project = result[0] expected_project_attributes = [ "id", "name", "short_name", "description", "project_page_url", "project_is_visible", "status", "visibility", "tasks", ] self.assertCountEqual(expected_project_attributes, project.keys()) task = project["tasks"][0] expected_task_attributes = [ "anonymise_url", "closing_date", "closing_date_desc", "description", "display_method", "earliest_start_date", "earliest_start_date_desc", "external_task_id", "id", "name", "short_name", "signup_available", "signup_status", "status", "task_is_visible", "task_page_url", "task_provider_name", "task_type_name", "url", "user_is_signedup", "user_specific_url", "user_task_status", "visibility", ] self.assertCountEqual(expected_task_attributes, task.keys())
def test_get_personal_link_api_invalid_account(self): invalid_account = "oxford" params = { "survey_id": self.default_survey_id, "anon_project_specific_user_id": self.default_anon_project_specific_user_id, "account": invalid_account, } expected_status = HTTPStatus.BAD_REQUEST result = test_utils.test_get( pl.get_personal_link_api, self.entity_base_url, querystring_parameters=params, ) self.assertEqual(expected_status, result["statusCode"])
def test_08_get_user_email_is_case_insensitive(self): querystring_parameters = {"email": "*****@*****.**"} expected_status = HTTPStatus.OK result = test_get( get_user_by_email_api, ENTITY_BASE_URL, querystring_parameters=querystring_parameters, ) result_status = result["statusCode"] result_json = json.loads(result["body"]) self.assertEqual(expected_status, result_status) self.assertDictEqual(EXPECTED_USER, result_json)
def test_03_list_user_tasks_api_project_task_not_exists(self): expected_status = HTTPStatus.OK expected_body = list() querystring_parameters = { "user_id": "851f7b34-f76c-49de-a382-7e4089b744e2", "project_task_id": "aa5092b1-b098-42d7-8c62-21493dfe37f3", } result = test_get(list_user_tasks_api, ENTITY_BASE_URL, None, querystring_parameters, None) result_status = result["statusCode"] result_json = json.loads(result["body"]) self.assertEqual(expected_status, result_status) self.assertEqual(expected_body, result_json)
def test_02_list_user_projects_api_user_not_exists(self): expected_status = HTTPStatus.NOT_FOUND querystring_parameters = {"user_id": "851f7b34-f76c-49de-a382-7e4089b744e3"} result = test_get( list_user_projects_api, ENTITY_BASE_URL, None, querystring_parameters, None ) result_status = result["statusCode"] result_json = json.loads(result["body"]) self.assertEqual(expected_status, result_status) self.assertTrue("correlation_id" in result_json) self.assertTrue( ("message" in result_json) and ("does not exist" in result_json["message"]) )
def test_user_e_demo_project_status_bad_include_non_visible_data_flag(self): user_id = "1cbe9aad-b29f-46b5-920e-b4c496d42515" # [email protected] response = test_get( get_project_status_for_user_api, f"v1/{ENTITY_BASE_URL}", None, { "user_id": user_id, "include_non_visible_data": "False", # string not lower case }, None, ) self.assertEqual(HTTPStatus.BAD_REQUEST, response["statusCode"])