def test_search_profiles(testing_server): users = utils.load_csv(USERS_PATH, use_unicode=True) for user in users[0:4]: session = assert_verify_login(user)[1] profile_data = build_profile_dict(user) assert_update_profile(user, session, profile_data) for user in users[4:8]: session = assert_verify_login(user)[1] profile_data = build_profile_dict(user) profile_data.update({"majors": "Physics"}) assert_update_profile(user, session, profile_data) physics_nursing_user = users[8] session = assert_verify_login(physics_nursing_user)[1] profile_data = build_profile_dict(physics_nursing_user) profile_data.update({"majors": "Physics,Nursing"}) assert_update_profile(physics_nursing_user, session, profile_data) expected_search_response = [{ "username": user["username"], "photo": DEFAULT_MASK_PHOTO, "email": user["email"], "full_name": user["full_name"], "views": "0", } for user in users[4:9]] search_response = mask_requests.get_profile_search( CURRENT_YEAR, dictionary_query={"majors": "physics"}) assert search_response.status_code == 200 actual_search_response = json.loads(search_response.text)["results"] for result in actual_search_response: assert result in expected_search_response assert len(actual_search_response) == len(expected_search_response)
def create_candidates(session, election_id, position_ids): """ creates a number of candidates for the given election :param session: an admin session used to create candidates :param position_ids: ids of positions to create candidates with :param election_id: a pre-existing election id :return: candidate data dictionary """ candidate_data = {} num_positions = len(position_ids) users = utils.load_csv(paths.USERS_PATH) for count, user in enumerate(users): response = auth_requests.post_verify(user['wwuid'], user['full_name'], user['email']) response_txt = json.loads(response.text)['user'] response_txt['email'] = user['email'] resp = candidate_requests.post_candidate(session, election_id, position_ids[count % num_positions], user['username'], user['full_name']) resp_data = json.loads(resp.text) candidate = {'position': position_ids[count % num_positions], 'username': user['username'], 'display_name': user['full_name']} assert (resp.status_code == 201) assert_candidate_data(resp_data, candidate) candidate_data[resp_data['id']] = resp_data return candidate_data
def test_profile_noauth_private(testing_server): """ If a user's privacy is set to 0, then only base info should be returned to a viewer not logged in. :return: """ viewee = utils.load_csv(USERS_PATH, use_unicode=True)[0] profile_data = build_profile_dict(viewee, {"privacy": "0"}) viewee_session = assert_verify_login(viewee)[1] assert_update_profile(viewee, viewee_session, profile_data) profile_response = mask_requests.get_profile(CURRENT_YEAR, viewee["username"]) expected_profile = { "email": viewee["email"], "full_name": viewee["full_name"], "photo": BASE_PROFILE["photo"], "username": viewee["username"], } actual_profile = json.loads(profile_response.text) assert profile_response.status_code == 200 utils.assert_is_equal_sub_dict(expected_profile, actual_profile) hidden_keys = SELF_FIELDS.union(PERSONAL_FIELDS).union(IMPERSONAL_FIELDS) utils.assert_does_not_contain_keys(actual_profile, hidden_keys)
def test_list_photos(testing_server): users = utils.load_csv(USERS_PATH)[0:3] photos = [ settings.environment["current_year"] + "/a01-" + users[1]["wwuid"] + ".jpg", settings.environment["current_year"] + "/a02-" + users[2]["wwuid"] + ".jpg", "1718" + "/a03-" + users[2]["wwuid"] + ".jpg", ] distutils.dir_util.create_tree( settings.environment["profile_photos_location"], photos) for photo in photos: utils.touch(settings.environment["profile_photos_location"] + "/" + photo) expected_empty_photos = [] session = assert_verify_login(users[0])[1] empty_response = mask_requests.get_list_profile_photos(session) actual_empty_response = json.loads(empty_response.text)["photos"] assert empty_response.status_code == 200 assert actual_empty_response == expected_empty_photos expected_many_photos = ["profiles/" + photo for photo in photos[1:3]] session = assert_verify_login(users[2])[1] many_response = mask_requests.get_list_profile_photos(session) actual_many_response = json.loads(many_response.text)["photos"] assert many_response.status_code == 200 assert len(actual_many_response) == 2 assert set(actual_many_response) == set(expected_many_photos)
def test_search_names(testing_server): users = utils.load_csv(USERS_PATH) for user in users: assert_verify_login(user) empty_response_query = "abcd" expected_empty_response = [] empty_query_response = mask_requests.get_search_names_fast( name_query=empty_response_query) actual_empty_response = json.loads(empty_query_response.text)["results"] assert empty_query_response.status_code == 200 assert len(actual_empty_response) == 0 assert actual_empty_response == expected_empty_response many_response_query = "e" expected_many_response = [ { 'username': '******', 'full_name': 'Delcie Lauer' }, { 'username': '******', 'full_name': 'Eugene Burnette' }, { 'username': '******', 'full_name': 'Lashay Semien' }, { 'username': '******', 'full_name': 'Melva Woullard' }, { 'username': '******', 'full_name': 'Raeann Castor' }, ] many_query_response = mask_requests.get_search_names_fast( name_query=many_response_query) actual_many_response = json.loads(many_query_response.text)["results"] assert many_query_response.status_code == 200 assert len(actual_many_response) == len(expected_many_response) expected_many_response = sorted(expected_many_response, key=lambda user: user["username"]) actual_many_response = sorted(actual_many_response, key=lambda user: user["username"]) assert actual_many_response == expected_many_response unique_response_query = "arm" expected_unique_response = [{ "username": "******", "full_name": "Armanda Woolston" }] unique_query_response = mask_requests.get_search_names_fast( name_query=unique_response_query) actual_unique_response = json.loads(unique_query_response.text)["results"] assert unique_query_response.status_code == 200 assert len(actual_unique_response) == 1 assert actual_unique_response == expected_unique_response
def create_elections(session): election_data = {} # Populate elections database elections = utils.load_csv(paths.ELECTIONS_PATH) for election in elections: resp_data = assert_post_election(session, election) election_data[resp_data['id']] = resp_data return election_data
def test_post_roles(testing_server): users = load_csv(USERS_PATH) for user in users: assert_verify_login(user) roles = ['demo_role_1', 'demo_role_2'] response = auth_requests.post_roles(user['wwuid'], roles) assert (response.status_code == 201) response_roles_data = json.loads(response.text)['user']['roles'] expected_roles_data = ','.join(roles) assert (response_roles_data == expected_roles_data)
def test_search_all(testing_server): users = utils.load_csv(USERS_PATH, use_unicode=True) expected_results = [] for user in users: user_session = assert_verify_login(user)[1] profile_data = build_profile_dict(user) assert_update_profile(user, user_session, profile_data) expected_result = dict() expected_result.update(user) expected_result.update({u"photo": BASE_PROFILE[u"photo"]}) del (expected_result[u"wwuid"]) expected_results.append(expected_result) all_response = mask_requests.get_search_all() expected_results = sorted(expected_results, key=lambda user: user[u"username"]) actual_results = sorted(json.loads(all_response.text)[u"results"], key=lambda user: user[u"username"]) assert all_response.status_code == 200 assert actual_results == expected_results
def test_profile_auth_self(testing_server): """ If a viewer is logged in and views their own profile they should receive the whole profile model. :return: """ user = utils.load_csv(USERS_PATH, use_unicode=True)[0] profile_data = build_profile_dict(user) user_session = assert_verify_login(user)[1] assert_update_profile(user, user_session, profile_data) profile_response = mask_requests.get_profile(CURRENT_YEAR, user["username"], user_session) expected_profile = build_profile_dict(user) actual_profile = json.loads(profile_response.text) assert profile_response.status_code == 200 utils.assert_is_equal_sub_dict(expected_profile, actual_profile)
def test_get_vote(testing_server): admin_session = election_subtests.create_elections_admin() election_id = election_subtests.assert_post_dynamic_election( admin_session)['id'] position_resp = position_requests.post_position( admin_session, POSITION_DATA['position'], POSITION_DATA['election_type'], POSITION_DATA['active'], POSITION_DATA['order']) position_id = json.loads(position_resp.text)['id'] vote_data = vote_subtests.create_votes(admin_session, election_id, position_id) users = utils.load_csv(paths.USERS_PATH) for count, user in enumerate(users): user_session = auth_subtests.assert_verify_login(user)[1] resp = vote_requests.get_vote(user_session, position_id, user['username']) assert (resp.status_code == 200) resp_text = json.loads(resp.text)['votes'] for vote in resp_text: vote_subtests.assert_vote_data(vote, vote_data[user['username']])
def create_votes(session, election_id, position_id): time.sleep(3) vote_data = {} users = utils.load_csv(paths.USERS_PATH) for count, user in enumerate(users): auth_requests.post_verify(user['wwuid'], user['full_name'], user['email']) user_session = auth_subtests.assert_verify_login(user)[1] vote = { 'election': election_id, 'position': position_id, "vote": user['username'] } resp = vote_requests.post_vote(user_session, election=election_id, position=position_id, vote=user['username']) resp_text = json.loads(resp.text) assert (resp.status_code == 201) assert_vote_data(resp_text, vote) vote_data[resp_text['username']] = resp_text return vote_data
def test_profile_auth_other(testing_server): """ If a viewer is logged in and views someone else's profile they should receive the view_other model. :return: """ viewee, viewer = utils.load_csv(USERS_PATH, use_unicode=True)[0:2] profile_data = build_profile_dict(viewee) viewee_session = assert_verify_login(viewee)[1] assert_update_profile(viewee, viewee_session, profile_data) viewer_session = assert_verify_login(viewer)[1] profile_response = mask_requests.get_profile(CURRENT_YEAR, viewee["username"], viewer_session) hidden_keys = SELF_FIELDS expected_profile = build_profile_dict(viewee, remove_keys=hidden_keys) actual_profile = json.loads(profile_response.text) assert profile_response.status_code == 200 utils.assert_is_equal_sub_dict(expected_profile, actual_profile) utils.assert_does_not_contain_keys(actual_profile, hidden_keys)
def test_profile_noauth_public(testing_server): """ If a user's privacy is set to 1, then impersonal info should be returned to a viewer not logged in. :return: """ viewee = utils.load_csv(USERS_PATH, use_unicode=True)[0] profile_data = build_profile_dict(viewee, {"privacy": "1"}) viewee_session = assert_verify_login(viewee)[1] assert_update_profile(viewee, viewee_session, profile_data) profile_response = mask_requests.get_profile(CURRENT_YEAR, viewee["username"]) hidden_keys = SELF_FIELDS.union(PERSONAL_FIELDS).union({"email"}) expected_profile = build_profile_dict(viewee, {"privacy": "1"}, hidden_keys) actual_profile = json.loads(profile_response.text) assert profile_response.status_code == 200 utils.assert_is_equal_sub_dict(expected_profile, actual_profile) utils.assert_does_not_contain_keys(actual_profile, hidden_keys)
def test_post_verify(testing_server): users = load_csv(USERS_PATH) for user in users: response = auth_requests.post_verify(user['wwuid'], user['full_name'], user['email']) assert_verify_response(response, user)
def test_get_verify(testing_server): users = load_csv(USERS_PATH) for user in users: assert_verify_login(user)
def test_update_profile(testing_server): users = utils.load_csv(USERS_PATH, use_unicode=True) for user in users: login_response_text, session = assert_verify_login(user) profile_data = build_profile_dict(user) assert_update_profile(user, session, profile_data)