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_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_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 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_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)