def test_comment_uncertified(driver, django_db_blocker):
# creating a user and leaving a comment, checking that it is not shown
username = str(uuid1())
domain = f"@{uuid1()}.com"
with django_db_blocker.unblock():
u = DjangoUser.objects.create_user(username=username, is_active=True)
EmailDomain.objects.create(domain=domain,
status=EmailDomain.STATUS_ACCEPTED)
ui = UserInformation.objects.create(user=u)
up = UserPreferences.objects.create(user=u)
v = Video.objects.create(video_id=random_alphanumeric())
VerifiableEmail.objects.create(user=ui, email=f"test{domain}")
VideoComment.objects.create(user=up, video=v, comment="test")
login(driver)
res = do_api_call_v2(driver,
'/video_comments/?video__video_id=' + v.video_id)
assert res['count'] == 0
with django_db_blocker.unblock():
VerifiableEmail.objects.filter(
user=ui, email=f"test{domain}").update(is_verified=True)
res = do_api_call_v2(driver,
'/video_comments/?video__video_id=' + v.video_id)
assert res['count'] == 1
logout(driver)
with django_db_blocker.unblock():
u.delete()
v.delete()
def test_no_show(driver, django_db_blocker):
login(driver)
with django_db_blocker.unblock():
username = "******" + str(uuid1())
u = DjangoUser.objects.create_user(username=username)
ui = UserInformation.objects.create(user=u, show_my_profile=False)
r = do_api_call_v2(driver=driver,
url=f'/user_information/{ui.id}/',
expect_fail=True)
assert not r.ok
r = do_api_call_v2(driver=driver,
url=f'/user_information/?user__username={username}')
assert r['count'] == 0
# test that can see my own hidden profile
with django_db_blocker.unblock():
UserInformation.objects.filter(user__username=test_username).update(
show_my_profile=False)
r = do_api_call_v2(
driver=driver,
url=f'/user_information/?user__username={test_username}')
assert r['count'] == 1
with django_db_blocker.unblock():
UserInformation.objects.filter(user__username=test_username).update(
show_my_profile=True)
logout(driver)
with django_db_blocker.unblock():
u.delete()
def test_withlogin(driver, django_db_blocker):
login(driver)
# going to user personal profile
driver.find_element_by_id('personal_info_menu').click()
# editing the profile
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'edit_userprofile_button_id')))
driver.find_element_by_id('edit_userprofile_button_id').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'to_verified_domains_class')))
# going to the list of domains
driver.find_element_by_class_name('to_verified_domains_class').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'domains')))
with _create_emails(django_db_blocker) as domains:
ack_email, rej_email, pend_email = domains
driver.refresh()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'domains')))
_test_domains(driver, ack_email, rej_email, pend_email)
logout(driver)
def test_feature_links(driver, django_db_blocker):
login(driver)
set_all_features_enabled(django_db_blocker)
print("Going to the expert interface...")
expert_interface_btn = driver.find_element_by_id('expert_interface')
expert_interface_btn.click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_expert_rating_page')))
for f in VIDEO_FIELDS:
elem_id = "id_explanation_" + f
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, elem_id)))
link = driver.find_element_by_id(elem_id).get_attribute('href')
assert link.startswith('http'), link
resp = get(link)
assert resp.ok
assert resp.status_code == 200
assert 'MediaWiki' in resp.text
print(f, resp.text[:500])
logout(driver)
def test_logging_user(client, session):
helpers.register(client, "*****@*****.**", "fluttershy", "UserTLU")
helpers.login(client, "*****@*****.**", "fluttershy")
rv = client.get("/user", follow_redirects=True)
assert b"*****@*****.**" in rv.data
helpers.logout(client)
assert b"Logged as UserTLU" in rv.data
def test_profile(client, session):
helpers.register(client, "*****@*****.**", "fluttershy", "UserTP")
helpers.login(client, "*****@*****.**", "fluttershy")
rv = client.get("/user", follow_redirects=True)
assert b"Please fill me !" in rv.data
assert b"Please fill me !" in rv.data
helpers.logout(client)
def test_my_ratings(driver, django_db_blocker):
# creating a video
login(driver)
with django_db_blocker.unblock():
me = UserPreferences.objects.get(user__username=test_username)
video_id1 = create_test_video()
video_id2 = create_test_video()
video_1 = Video.objects.get(video_id=video_id1)
video_2 = Video.objects.get(video_id=video_id2)
ExpertRating.objects.create(video_1=video_1,
video_2=video_2,
**{k: 50
for k in VIDEO_FIELDS},
user=me)
open_more_menu(driver)
WebDriverWait(driver, TIME_WAIT).until(
EC.visibility_of_element_located((By.ID, 'video_details_menu')))
print("Going to the details page")
expert_interface_btn = driver.find_element_by_id('video_details_menu')
expert_interface_btn.click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'video_id_text_field')))
elem = driver.find_element_by_class_name('video_id_text_field')
elem = elem.find_element_by_tag_name('input')
elem.clear()
elem.send_keys(video_id1, Keys.HOME)
if elem.get_attribute('value') != video_id1:
elem.send_keys(3 * [Keys.DELETE])
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'button_video_ratings')))
# opening ratings page
driver.find_element_by_class_name('button_video_ratings').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_my_ratings')))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'video_rating_video')))
# have only 1 rating
assert len(driver.find_elements_by_class_name('video_rating_video')) == 1
# rerate
driver.find_elements_by_class_name('video_rating_rerate')[0].click()
# on the right page
assert driver.current_url.split('/')[-2:] == [video_id1, video_id2]
logout(driver)
def test_change_password(client, session):
init_password = "******"
new_password = "******"
register(client, "*****@*****.**", init_password, "UserB")
# Can login with initial password
rv = login(client, "*****@*****.**", init_password)
assert b"Logged as UserB" in rv.data
# Change password
resp = client.post(
"/change",
data=dict(password=init_password,
new_password=new_password,
new_password_confirm=new_password),
follow_redirects=True,
)
assert resp.status_code == 200
assert b"You successfully changed your password." in resp.data
# Logout
logout(client)
# Test login with new password
resp = login(client, "*****@*****.**", new_password)
print(resp.data)
assert b"Logged as UserB" in resp.data
logout(client)
# Test login with old password
resp = login(client, "*****@*****.**", init_password)
assert b"Invalid password" in resp.data
def test_password_reset(driver, django_db_blocker):
open_tournesol(driver)
# making my emails verified
with django_db_blocker.unblock():
ui = UserInformation.objects.get(user__username=test_username)
ve = VerifiableEmail.objects.create(user=ui,
email="*****@*****.**",
is_verified=True)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, "login_button")))
driver.find_element_by_id('login_button').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, "id_reset_password")))
driver.find_element_by_id('id_reset_password').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, "id_reset_submit")))
username = driver.find_element_by_id('root_username')
username.clear()
username.send_keys(test_username)
driver.find_element_by_id('id_reset_submit').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, "id_email_instructions")))
email_parsed = get_last_email()
email_payload = None
for payload in email_parsed.walk():
email_payload = payload.get_payload()
assert email_payload
assert 'password reset' in email_payload
print(email_payload)
link = email_payload.strip().splitlines()
link = [x for x in link
if x.startswith(settings.EMAIL_PAGE_DOMAIN)][0].strip()
print(link)
link_no_domain = link[len(settings.EMAIL_PAGE_DOMAIN):]
link_local_domain = web_url + '/' + link_no_domain
driver.get(link_local_domain)
print(link, link_no_domain, link_local_domain)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, "root_password")))
assert driver.find_element_by_id('root_password')
logout(driver)
with django_db_blocker.unblock():
ve.delete()
def test_user_ui_pref_videos(driver, django_db_blocker):
"""Test that user preferences are saved and videos are shown."""
login(driver)
with django_db_blocker.unblock():
create_test_video(name="test")
print("Going to user interface")
ui_button = driver.find_element_by_id('user_interface')
ui_button.click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'search_phrase')))
print("Typing search phrase")
search_phrase_field = driver.find_element_by_id('search_phrase')
search_phrase_field.clear()
search_phrase_field.send_keys('test')
# random preferences
np.random.seed(42)
values = np.random.rand(len(VIDEO_FIELDS)) * 100
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_search_not_loading')))
for f, v in zip(VIDEO_FIELDS, values):
set_slider_value(driver, s_id='preference_slider_' + f, value=v)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_search_not_loading')))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_search_not_loading')))
print("Loading recommendations")
load_rec_btn = driver.find_element_by_id("load_recommendations")
load_rec_btn.click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_search_not_loading')))
entry = do_api_call_v2(driver, url='/user_preferences/my/')
values_got = [entry[x] for x in VIDEO_FIELDS]
values_transformed = values / 2 + 50
diff = np.max(np.abs(values_transformed - values_got))
assert diff < 5, (values_transformed, values_got)
print("Preferences normal", diff)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'video_search_result')))
videos = driver.find_elements_by_class_name('video_search_result')
assert videos, "No videos returned in search, or it took too long."
print("Got", len(videos), "videos")
logout(driver)
def test_submit_video(driver):
login(driver)
print("Going to the expert interface...")
expert_interface_btn = driver.find_element_by_id('expert_interface')
expert_interface_btn.click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'video-left')))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'video-right')))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
# print("Skipping tutorial")
# skip_tutorial_btn = driver.find_element_by_id('start_comparing_button')
# skip_tutorial_btn.click()
vid1 = shortuuid.ShortUUID().random(length=10)
vid2 = shortuuid.ShortUUID().random(length=10)
def set_video(which, vid_id):
selector = driver.find_element_by_id(which)
c = selector.find_element_by_class_name('video_id_text_field')
c = c.find_elements_by_tag_name('input')[0]
c.clear()
c.send_keys(vid_id)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
set_video('video-left', vid1)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
set_video('video-right', vid2)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
expert_submit_btn = driver.find_element_by_id('expert_submit_btn')
expert_submit_btn.click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_submitted_text_info')))
assert do_api_call_v2(driver,
url=f"/videos/?video_id={vid1}")['count'] >= 1
assert do_api_call_v2(driver,
url=f"/videos/?video_id={vid2}")['count'] >= 1
logout(driver)
def test_premissions(driver):
login(driver)
driver.get(web_url + '/admin/')
assert 'login' in driver.current_url
driver.get(web_url + '/files/')
assert '403 Forbidden' in driver.page_source
driver.get(web_url)
logout(driver)
def wrapper(*args, **kwargs):
if current_app.config["INVITE_MODE"]:
g.recommender = None
logout()
rid = session.get("rid", None)
if rid:
g.recommender = current_app.redis.hgetall("user:%s" % rid)
if g.recommender:
return method(*args, **kwargs)
return redirect(url_for("account.confirm_invitation", next=request.url))
else:
return method(*args, **kwargs)
def signup(driver, django_db_blocker, username, password, email):
open_tournesol(driver)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, "signup_button")))
# sign up
driver.find_element_by_id('signup_button').click()
user_data = {
'root_username': username,
'root_email': email,
'root_password': password,
'root_password2': password
}
for key, val in user_data.items():
elem = driver.find_element_by_id(key)
elem.clear()
elem.send_keys(val)
# accepting the privacy policy
pp_ckbox = driver.find_element_by_id('root_shrivacy_policy')
if not pp_ckbox.get_property('checked'):
pp_ckbox.click()
buttons = driver.find_elements_by_tag_name('button')
buttons = [x for x in buttons if x.get_attribute('type') == 'submit']
assert len(buttons) == 1
buttons[0].click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_email_instructions')))
driver.delete_all_cookies()
driver.get(web_url)
with django_db_blocker.unblock():
# manually activating the user
user = DjangoUser.objects.get(username=user_data['root_username'])
user.is_active = True
user.save()
login(driver,
test_username=user_data['root_username'],
test_password=user_data['root_password'])
logout(driver)
return user_data
def test_home_page_link_smaller(driver, django_db_blocker):
login(driver)
with django_db_blocker.unblock():
VideoRateLater.objects.filter(user__user__username=test_username).delete()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_home_toratelater')))
driver.find_element_by_id('id_home_toratelater').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_ratelater_page_all')))
logout(driver)
def test_privacy(driver, django_db_blocker):
login(driver)
# privacy test
# creating a temp user
with django_db_blocker.unblock():
u = DjangoUser.objects.create_user(username="******" + str(uuid1()))
ui = UserInformation.objects.create(user=u)
def check_sensitive(res):
assert 'gender' not in res
assert 'race' not in res
assert 'emails' not in res
assert 'nationality' not in res
assert 'residence' not in res
assert 'moral_philosophy' not in res
assert 'political_affiliation' not in res
assert 'degree_of_political_engagement' not in res
assert 'religion' not in res
with django_db_blocker.unblock():
ui.show_online_presence = True
ui.save()
res = do_api_call_v2(driver=driver, url=f'/user_information/{ui.id}/')
check_sensitive(res)
for x in [
'google_scholar', 'website', 'linkedin', 'orcid', 'twitter',
'youtube', 'researchgate'
]:
assert x in res
with django_db_blocker.unblock():
ui.show_online_presence = False
ui.save()
res = do_api_call_v2(driver=driver, url=f'/user_information/{ui.id}/')
check_sensitive(res)
for x in [
'google_scholar', 'website', 'linkedin', 'orcid', 'twitter',
'youtube', 'researchgate'
]:
assert x not in res
with django_db_blocker.unblock():
u.delete()
logout(driver)
def test_representative_search(driver, django_db_blocker):
with django_db_blocker.unblock():
u = DjangoUser.objects.create(username=random_alphanumeric(),
is_active=True)
up = UserPreferences.objects.create(user=u)
UserInformation.objects.create(user=u, show_my_profile=True)
video_id = create_test_video()
video = Video.objects.get(video_id=video_id)
ratings = {f: np.random.randn() for f in VIDEO_FIELDS}
VideoRating.objects.create(user=up, video=video, **ratings)
VideoRatingPrivacy.objects.create(user=up, video=video, is_public=True)
login(driver)
ui_button = driver.find_element_by_id('user_interface')
ui_button.click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'search_options')))
driver.find_element_by_class_name('search_options').click()
inp_model = driver.find_element_by_id('autocomplete_search_model')
inp_model.send_keys(len('Aggregated') * [Keys.BACK_SPACE])
inp_model.send_keys(f"{u.username}'s representative")
driver.find_element_by_class_name('MuiAutocomplete-popper').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_search_not_loading')))
print("Loading recommendations")
load_rec_btn = driver.find_element_by_id("load_recommendations")
load_rec_btn.click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_search_not_loading')))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, f'video_card_id_{video_id}')))
# now will only see 1 video
assert driver.find_elements_by_class_name(f'video_card_id_{video_id}')
logout(driver)
with django_db_blocker.unblock():
u.delete()
Video.objects.filter(video_id=video_id).delete()
def test_login_logout(client, session):
"""Make sure login and logout works."""
resp = register(client, "*****@*****.**", "fluttershy", "UserA",
"User A")
assert resp.status_code == 200
resp = json.loads(resp.data)
assert "created_at" in resp
assert "access_token" in resp
rv = login(client, "*****@*****.**", "fluttershy")
rv = client.get("/home")
assert rv.status_code == 200
assert b"Logged as UserA" in rv.data
rv = logout(client)
rv = client.get("/home")
assert rv.status_code == 200
assert b"UserA" not in rv.data
rv = login(client, "*****@*****.**" + "x", "fluttershy")
assert rv.status_code == 200
assert b"Specified user does not exist" in rv.data
rv = login(client, "*****@*****.**", "fluttershy" + "x")
assert rv.status_code == 200
assert b"Invalid password" in rv.data
def test_register_two_identical_users(client, session):
# Will register
register(client, "*****@*****.**", "fluttershy", "ImUnique")
logout(client)
# Try to register another identical
resp = client.post(
"/register",
data=dict(email="*****@*****.**",
password="******",
password_confirm="fluttershy",
name="ImUnique"),
follow_redirects=True,
)
# should error
assert b"Logged as" not in resp.data
assert b"[email protected] is already associated " b"with an account." in resp.data
assert b"Username already taken" in resp.data
assert resp.status_code == 200
def test_change_password(client, session):
pytest.skip("outdated test :(")
init_password = "******"
new_password = "******"
resp = register(client, "*****@*****.**", init_password, "UserB",
"User B")
assert resp.status_code == 200
resp = json.loads(resp.data)
assert "created_at" in resp
assert "access_token" in resp
# Can login with initial password
rv = login(client, "*****@*****.**", init_password)
rv = client.get("/home")
assert rv.status_code == 200
assert b"Logged as UserB" in rv.data
# Change password
# no follow redirect or boom
resp = client.post(
"/change",
data=dict(password=init_password,
new_password=new_password,
new_password_confirm=new_password),
follow_redirects=False,
)
assert resp.status_code == 302
# Logout
logout(client)
# Test login with new password
resp = login(client, "*****@*****.**", new_password)
rv = client.get("/home")
print(resp.data)
# assert b"Logged as UserB" in resp.data
logout(client)
# Test login with old password
resp = login(client, "*****@*****.**", init_password)
assert b"Invalid password" in resp.data
def test_user_profile_navigate(driver, django_db_blocker):
"""Test that going from another person's profile to mine works, see #309."""
with django_db_blocker.unblock():
other_username = random_alphanumeric()
u = DjangoUser.objects.create_user(username=other_username)
print(other_username)
login(driver)
with django_db_blocker.unblock():
UserInformation.objects.filter(user__username=test_username)\
.update(first_name='Selenium')
UserInformation.objects.filter(user__username=other_username)\
.update(first_name='Other user')
driver.get(web_url + '/user/' + other_username)
def current_profile_first_name():
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, "id_user_page_loaded")))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.ID, "id_first_last_name_certified_user")))
result = driver.find_element_by_id(
'id_first_last_name_certified_user').text
print('firstname', result)
return result
assert current_profile_first_name().startswith('Other user')
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, "personal_info_menu")))
driver.find_element_by_id('personal_info_menu').click()
assert current_profile_first_name().startswith('Selenium')
with django_db_blocker.unblock():
u.delete()
logout(driver)
def test_data_download(driver, django_db_blocker):
login(driver)
driver.find_element_by_id('personal_info_menu').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, "id_my_data_download")))
link = driver.find_element_by_id('id_my_data_download').get_attribute(
'href')
cookies_dict = get_cookies(driver)
headers = {'X-CSRFToken': cookies_dict.get('csrftoken')}
data = get(link, cookies=cookies_dict, headers=headers)
assert data.ok
assert data.content
assert data.headers['content-type'] == 'application/zip'
logout(driver)
def test_home_page_link_enough(driver, django_db_blocker):
with django_db_blocker.unblock():
VideoRateLater.objects.filter(user__user__username=test_username).delete()
video_ids = [create_test_video() for _ in range(minNumRateLater)]
videos = [Video.objects.get(video_id=vid) for vid in video_ids]
dj_u = DjangoUser.objects.get(username=test_username)
up, _ = UserPreferences.objects.get_or_create(user=dj_u)
[VideoRateLater.objects.create(video=v, user=up) for v in videos]
login(driver)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_home_toexpert')))
driver.find_element_by_id('id_home_toexpert').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
logout(driver)
def test_webfinger(client, session):
register(client, "*****@*****.**", "fluttershy",
"TestWebfinger")
logout(client)
rv = client.get(
f"/.well-known/webfinger?resource=acct:TestWebfinger@{current_app.config['AP_DOMAIN']}"
)
assert rv.status_code == 200
assert rv.headers["Content-Type"] == "application/jrd+json; charset=utf-8"
datas = rv.json
assert "aliases" in datas
assert f"https://{current_app.config['AP_DOMAIN']}/user/TestWebfinger" in datas[
"aliases"]
assert "links" in datas
assert "subject" in datas
assert datas[
"subject"] == f"acct:TestWebfinger@" f"{current_app.config['AP_DOMAIN']}"
def test_only_default_enabled(driver, django_db_blocker):
with django_db_blocker.unblock():
UserPreferences.objects.filter(user__username=test_username).delete()
login(driver)
with django_db_blocker.unblock():
up = UserPreferences.objects.get(user__username=test_username)
print("Going to the expert interface...")
expert_interface_btn = driver.find_element_by_id('expert_interface')
expert_interface_btn.click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_expert_rating_page')))
for f in VIDEO_FIELDS:
assert featureIsEnabledByDeFault[f] == getattr(up, f + "_enabled")
check_feature_visibility(up, driver)
logout(driver)
def test_submit_to_add_later_url(driver, django_db_blocker):
"""Add video to rate later list via a URL."""
login(driver)
video_id = random_alphanumeric()
driver.get(web_url + '/rate_later_add/' + video_id)
# checking that submission succeeded
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_rate_later_submit_ok')))
# checking that list is present
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'class_rate_later_list')))
# checking that the video is in the list
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, f'id_{video_id}_remove_rate_later')))
# doing the same thing, but now will get a warning
driver.refresh()
# checking that submission succeeded
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_rate_later_submit_already_exists')))
# checking that list is present
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'class_rate_later_list')))
# checking that the video is in the list
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, f'id_{video_id}_remove_rate_later')))
with django_db_blocker.unblock():
Video.objects.filter(video_id=video_id).delete()
logout(driver)
def test_login_logout(client, session):
"""Make sure login and logout works."""
register(client, "*****@*****.**", "fluttershy", "UserA")
rv = login(client, "*****@*****.**", "fluttershy")
assert rv.status_code == 200
assert b"Logged as UserA" in rv.data
rv = logout(client)
assert rv.status_code == 200
assert b"UserA" not in rv.data
rv = login(client, "*****@*****.**" + "x", "fluttershy")
assert rv.status_code == 200
assert b"Specified user does not exist" in rv.data
rv = login(client, "*****@*****.**", "fluttershy" + "x")
assert rv.status_code == 200
assert b"Invalid password" in rv.data
def test_signup_verify_email(driver, django_db_blocker):
# removing old emails
shutil.rmtree(EMAIL_FILE_PATH)
os.makedirs(EMAIL_FILE_PATH, exist_ok=True)
with django_db_blocker.unblock():
pending_domain = f"@{random_alphanumeric()}.com"
accepted_domain = f"@{random_alphanumeric()}.com"
rejected_domain = f"@{random_alphanumeric()}.com"
# EmailDomain.objects.create(domain=pending_domain,
# status=EmailDomain.STATUS_PENDING)
EmailDomain.objects.create(domain=accepted_domain,
status=EmailDomain.STATUS_ACCEPTED)
EmailDomain.objects.create(domain=rejected_domain,
status=EmailDomain.STATUS_REJECTED)
signup(driver,
django_db_blocker,
username=random_alphanumeric(),
password=secrets.token_urlsafe(32),
email=f"test_first{pending_domain}")
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, "signup_button")))
two_last = [get_last_email(offset) for offset in [-1, -2]]
two_last_from = [x.get('From', "") for x in two_last]
assert any([x == EMAIL_NEWDOMAIN_ADDRESS
for x in two_last_from]), two_last_from
domains = {
'pending': f"{random_alphanumeric()}{pending_domain}",
'rejected': f"{random_alphanumeric()}{rejected_domain}",
'accepted': f"{random_alphanumeric()}{accepted_domain}",
}
for email_type, email_address in domains.items():
driver.get(web_url)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, "signup_button")))
# sign up
driver.find_element_by_id('signup_button').click()
password = secrets.token_urlsafe(32)
user_data = {
'root_username': str(uuid1()),
'root_email': email_address,
'root_password': password,
'root_password2': password
}
for key, val in user_data.items():
elem = driver.find_element_by_id(key)
elem.clear()
elem.send_keys(val)
# accepting the privacy policy
pp_ckbox = driver.find_element_by_id('root_shrivacy_policy')
if not pp_ckbox.get_property('checked'):
pp_ckbox.click()
buttons = driver.find_elements_by_tag_name('button')
buttons = [x for x in buttons if x.get_attribute('type') == 'submit']
assert len(buttons) == 1
buttons[0].click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.ID, "button_home_page_to_verify_id")))
# going to the home page
driver.find_element_by_id('button_home_page_to_verify_id').click()
email_parsed = get_last_email()
email_payload = None
for payload in email_parsed.walk():
if payload.get_content_type() == 'text/html':
email_payload = payload.get_payload()
assert email_payload
html_parsed = html.parse(StringIO(email_payload))
assert html_parsed.xpath("//p[@id = 'confirmation_text_id']")
for email_other_type in domains.keys():
items = html_parsed.xpath(
f"//*[@id = 'email_{email_other_type}_id']")
if email_other_type == email_type:
assert items
else:
assert not items, (email_type, email_other_type, email_payload,
email_address)
# confirming e-mail address
confirm_link = html_parsed.xpath(
"//a[@id = 'confirmation_link_id']")[0].get('href')
confirm_link = confirm_link.replace(EMAIL_PAGE_DOMAIN,
'http://127.0.0.1:8000/')
print("Navigating to", confirm_link)
driver.get(confirm_link)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.ID, "button_home_page_verified_id")))
# going to the home page
driver.find_element_by_id('button_home_page_verified_id').click()
open_tournesol(driver)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, "login_button")))
login(driver,
test_username=user_data['root_username'],
test_password=user_data['root_password'])
logout(driver)
with django_db_blocker.unblock():
DjangoUser.objects.filter(
username=user_data['root_username']).delete()
def test_rate_confidence(driver, django_db_blocker):
"""Test skips mode."""
login(driver)
with django_db_blocker.unblock():
# creating two videos
video_1_id = create_test_video()
video_2_id = create_test_video()
# setting user preferences
up = UserPreferences.objects.get(user__username=test_username)
# enabling two features
for f in VIDEO_FIELDS[:4]:
setattr(up, f"{f}_enabled", True)
for f in VIDEO_FIELDS[4:]:
setattr(up, f"{f}_enabled", False)
f0, f1 = VIDEO_FIELDS[:2]
# setting mode to enable_all
up.rating_mode = "confidence"
up.save()
driver.get(web_url + f'/rate/{video_1_id}/{video_2_id}')
# waiting for the page to load
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
check_feature_visibility(up, driver)
# setting stars
stars_set_value(driver, VIDEO_FIELDS[0] + "_confidence", 0)
stars_set_value(driver, VIDEO_FIELDS[1] + "_confidence", 1)
stars_set_value(driver, VIDEO_FIELDS[2] + "_confidence", 2)
stars_set_value(driver, VIDEO_FIELDS[3] + "_confidence", 3)
print("Submitting the rating...")
expert_submit_btn = driver.find_element_by_id('expert_submit_btn')
expert_submit_btn.click()
with django_db_blocker.unblock():
obj = get_object_with_timeout(ExpertRating,
video_1__video_id=video_1_id,
video_2__video_id=video_2_id,
user__user__username=test_username)
# checking weight
assert getattr(obj, f"{VIDEO_FIELDS[0]}_weight") == 0.0
assert getattr(obj, f"{VIDEO_FIELDS[1]}_weight") == 0.5
assert getattr(obj, f"{VIDEO_FIELDS[2]}_weight") == 1.0
assert getattr(obj, f"{VIDEO_FIELDS[3]}_weight") == 1.5
for f in VIDEO_FIELDS[4:]:
assert getattr(obj, f"{f}_weight") == 0.0
# now, setting second value to None
setattr(obj, VIDEO_FIELDS[1], None)
obj.save()
# editing the rating with default None values and wrong weights
driver.refresh()
# waiting for the page to load
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
print("Submitting the rating...")
expert_submit_btn = driver.find_element_by_id('expert_submit_btn')
expert_submit_btn.click()
with django_db_blocker.unblock():
obj = get_object_with_timeout(
ExpertRating,
video_1__video_id=video_1_id,
video_2__video_id=video_2_id,
user__user__username=test_username,
**{VIDEO_FIELDS[0] + "_weight__lte": 0.5})
# checking that weights are 1 for the first feature and 0 for the rest
assert getattr(obj, f"{VIDEO_FIELDS[0]}_weight") == 0.0
assert getattr(obj, f"{VIDEO_FIELDS[1]}_weight") == 0.0
assert getattr(obj, f"{VIDEO_FIELDS[2]}_weight") == 1.0
assert getattr(obj, f"{VIDEO_FIELDS[3]}_weight") == 1.5
for f in VIDEO_FIELDS[4:]:
assert getattr(obj, f"{f}_weight") == 0.0
assert getattr(obj, VIDEO_FIELDS[0]) is not None
with django_db_blocker.unblock():
Video.objects.filter(video_id__in=[video_1_id, video_2_id]).delete()
logout(driver)
def test_rate_skips(driver, django_db_blocker):
"""Test skips mode."""
login(driver)
with django_db_blocker.unblock():
# creating two videos
video_1_id = create_test_video()
video_2_id = create_test_video()
# setting user preferences
up = UserPreferences.objects.get(user__username=test_username)
# enabling two features
for f in VIDEO_FIELDS[:2]:
setattr(up, f"{f}_enabled", True)
for f in VIDEO_FIELDS[2:]:
setattr(up, f"{f}_enabled", False)
f0, f1 = VIDEO_FIELDS[:2]
# setting mode to enable_all
up.rating_mode = "skip"
up.save()
driver.get(web_url + f'/rate/{video_1_id}/{video_2_id}')
# waiting for the page to load
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
check_feature_visibility(up, driver)
# checkboxes should be unchecked
elem0 = driver.find_element_by_id("id_checkbox_skip_" + f0)
elem1 = driver.find_element_by_id("id_checkbox_skip_" + f1)
assert elem0.get_property('checked') is False
assert elem1.get_property('checked') is False
elem1.click()
print("Submitting the rating...")
expert_submit_btn = driver.find_element_by_id('expert_submit_btn')
expert_submit_btn.click()
with django_db_blocker.unblock():
obj = get_object_with_timeout(ExpertRating,
video_1__video_id=video_1_id,
video_2__video_id=video_2_id,
user__user__username=test_username)
# checking that weights are 1 for the first feature and 0 for the rest
for i, f in enumerate(VIDEO_FIELDS):
val = 1.0 if (i == 0) else 0.0
assert getattr(obj, f"{f}_weight") == val
# now, setting first value to None
setattr(obj, VIDEO_FIELDS[0], None)
obj.save()
# editing the rating with default None values and wrong weights
driver.refresh()
# waiting for the page to load
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
elem0 = driver.find_element_by_id("id_checkbox_skip_" + f0)
elem1 = driver.find_element_by_id("id_checkbox_skip_" + f1)
assert elem0.get_property('checked') is True
assert elem1.get_property('checked') is True
print("Submitting the rating...")
expert_submit_btn = driver.find_element_by_id('expert_submit_btn')
expert_submit_btn.click()
with django_db_blocker.unblock():
obj = get_object_with_timeout(
ExpertRating,
video_1__video_id=video_1_id,
video_2__video_id=video_2_id,
user__user__username=test_username,
**{VIDEO_FIELDS[0] + "_weight__lte": 0.5})
# checking that weights are 1 for the first feature and 0 for the rest
for i, f in enumerate(VIDEO_FIELDS):
assert getattr(obj, f"{f}_weight") == 0.0
assert getattr(obj, VIDEO_FIELDS[0]) is not None
with django_db_blocker.unblock():
Video.objects.filter(video_id__in=[video_1_id, video_2_id]).delete()
logout(driver)
def test_rate_enable_all_weight_none(driver, django_db_blocker):
"""Test all features enabled mode."""
login(driver)
with django_db_blocker.unblock():
# creating two videos
video_1_id = create_test_video()
video_2_id = create_test_video()
# setting user preferences
up = UserPreferences.objects.get(user__username=test_username)
# disabling all features, except for the first one
setattr(up, f"{VIDEO_FIELDS[0]}_enabled", True)
for f in VIDEO_FIELDS[1:]:
setattr(up, f"{f}_enabled", False)
# setting mode to enable_all
up.rating_mode = "enable_all"
up.save()
driver.get(web_url + f'/rate/{video_1_id}/{video_2_id}')
# waiting for the page to load
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
check_feature_visibility(up, driver)
print("Submitting the rating...")
expert_submit_btn = driver.find_element_by_id('expert_submit_btn')
expert_submit_btn.click()
with django_db_blocker.unblock():
obj = get_object_with_timeout(ExpertRating,
video_1__video_id=video_1_id,
video_2__video_id=video_2_id,
user__user__username=test_username)
# checking that weights are 1 for the first feature and 0 for the rest
for i, f in enumerate(VIDEO_FIELDS):
val = 1.0 if (i == 0) else 0.0
assert getattr(obj, f"{f}_weight") == val
# now, setting first value to None
# and first weight to None
setattr(obj, VIDEO_FIELDS[0], None)
setattr(obj, VIDEO_FIELDS[0] + "_weight", 0.0)
obj.save()
# editing the rating with default None values and wrong weights
driver.refresh()
print(video_1_id, video_2_id)
# waiting for the page to load
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
print("Submitting the rating...")
expert_submit_btn = driver.find_element_by_id('expert_submit_btn')
expert_submit_btn.click()
with django_db_blocker.unblock():
obj = get_object_with_timeout(ExpertRating,
video_1__video_id=video_1_id,
video_2__video_id=video_2_id,
user__user__username=test_username,
**{VIDEO_FIELDS[0] + "_weight__gt": 0.5})
# checking that weights are 1 for the first feature and 0 for the rest
for i, f in enumerate(VIDEO_FIELDS):
val = 1.0 if (i == 0) else 0.0
assert getattr(obj, f"{f}_weight") == val
assert getattr(obj, VIDEO_FIELDS[0]) is not None
with django_db_blocker.unblock():
Video.objects.filter(video_id__in=[video_1_id, video_2_id]).delete()
logout(driver)
