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_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 fill_rate_later(django_db_blocker):
with django_db_blocker.unblock():
dj_u = DjangoUser.objects.get(username=test_username)
up, _ = UserPreferences.objects.get_or_create(user=dj_u)
video_ids = [create_test_video() for _ in range(10)]
videos = [Video.objects.get(video_id=vid) for vid in video_ids]
[VideoRateLater.objects.create(user=up, video=v) for v in videos]
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_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_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)
def test_set_privacy_settings(driver, django_db_blocker):
cleanup_rate_later(django_db_blocker)
with django_db_blocker.unblock():
video_id1 = create_test_video()
video_id2 = create_test_video()
u = DjangoUser.objects.get(username=test_username)
ui, _ = UserInformation.objects.get_or_create(user=u)
ui.show_my_profile = True
ui.save()
up, _ = UserPreferences.objects.get_or_create(user=u)
EmailDomain.objects.create(domain="@tournesol.app",
status=EmailDomain.STATUS_ACCEPTED)
VerifiableEmail.objects.create(user=ui,
email="*****@*****.**",
is_verified=True)
ExpertRating.objects.create(
user=up,
video_1=Video.objects.get(video_id=video_id1),
video_2=Video.objects.get(video_id=video_id2))
Video.recompute_computed_properties(only_pending=True)
login(driver)
fill_rate_later(django_db_blocker)
set_all_features_enabled(django_db_blocker)
driver.get(web_url + '/rate/' + video_id1 + '/' + video_id2)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_expert_rating_page')))
def check_privacy_status(video_id1,
is_private,
check_db=True,
check_api=False):
with django_db_blocker.unblock():
Video.recompute_computed_properties(only_pending=True)
priv_public = 'private' if is_private else 'public'
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.ID, f'id_video_{video_id1}_{priv_public}')))
if check_db:
with django_db_blocker.unblock():
get_object_with_timeout(VideoRatingPrivacy,
video__video_id=video_id1,
user=up,
is_public=not is_private)
if check_api:
pe = do_api_call_v2(driver, '/videos/?video_id=' +
video_id1)['results'][0]['public_experts']
if is_private:
assert len(pe) == 0
else:
assert len(pe) == 1, pe
assert pe[0]['username'] == test_username
def set_privacy(video_id1, is_private):
# opening the privacy menu...
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.ID, f'id_open_privacy_menu_{video_id1}')))
driver.find_element_by_id(f'id_open_privacy_menu_{video_id1}').click()
priv_true_false = 'true' if is_private else 'false'
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.ID, f'menu_set_private_{priv_true_false}_{video_id1}')))
driver.find_element_by_id(
f'menu_set_private_{priv_true_false}_{video_id1}').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.element_to_be_clickable(
(By.ID, f'id_open_privacy_menu_{video_id1}')))
original_is_private = not VideoRatingPrivacy.DEFAULT_VALUE_IS_PUBLIC
check_privacy_status(video_id1, original_is_private, check_db=False)
set_privacy(video_id1, not original_is_private)
check_privacy_status(video_id1, not original_is_private, check_api=True)
set_privacy(video_id1, original_is_private)
check_privacy_status(video_id1, original_is_private, check_api=True)
logout(driver)
cleanup_rate_later(django_db_blocker)
def test_insert_video_id(driver, django_db_blocker):
"""Test that we can insert videos into the Video ID field in VideoSelector."""
cleanup_rate_later(django_db_blocker)
set_all_features_enabled(django_db_blocker)
# format: text to insert -> resulting stored ID or None if no record should exist
ids_to_insert = {
'https://www.youtube.com/watch?v=gU-mkuMU428&ab_channel=LexFridman':
'gU-mkuMU428',
'https://youtu.be/gU-mkuMU428':
'gU-mkuMU428',
'https://www.youtube.com/embed/gU-mkuMU428':
'gU-mkuMU428',
'gU-mkuMU428':
'gU-mkuMU428',
'@@@-':
'-',
'ghslkdfjghklsdjfghksldjfdskljfghskdljfghlskdjfghsldkfjghsldkfjghsfldgjkshdlkfg':
'ghslkdfjghklsdjfghks',
'$$$$$????++++-':
'-',
'| rm -rf / ':
'rm-rf',
'"""-':
'-'
}
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, 'id_expert_rating_page')))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
def get_input_elem(vid):
"""Get the input element for a video selector."""
print("Processing selector", vid)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, vid)))
# refreshing videos
selector = driver.find_element_by_id(vid)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'video_id_text_field')))
print("Obtaining element...")
elem = selector.find_element_by_class_name('video_id_text_field')
elem = elem.find_element_by_tag_name('input')
return elem
# creating the left video
with django_db_blocker.unblock():
video_id_left = create_test_video()
def process_video_selector(vid, video_enter):
"""Load new video."""
elem = get_input_elem(vid)
elem.clear()
clipboard.copy(video_enter)
print("Copying text", video_enter, "into", vid)
elem.send_keys(Keys.LEFT_CONTROL, "v")
for text_enter, resulting_id in ids_to_insert.items():
with django_db_blocker.unblock():
ExpertRating.objects.filter(
user__user__username=test_username).delete()
print("Entering", text_enter, "expecting", resulting_id)
process_video_selector('video-left', video_id_left)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
process_video_selector('video-right', text_enter)
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()
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_no_pending_submit')))
if resulting_id is not None:
with django_db_blocker.unblock():
get_object_with_timeout(ExpertRating,
video_1__video_id=video_id_left,
video_2__video_id=resulting_id,
user__user__username=test_username)
else:
with django_db_blocker.unblock():
assert ExpertRating.objects.filter(
user__user__username=test_username).count() == 0
logout(driver)
def test_cyclic_create_view_resolve(driver, django_db_blocker):
# creating 3 videos
video_ids = []
with django_db_blocker.unblock():
for _ in range(3):
video_ids.append(create_test_video())
videos = [Video.objects.get(video_id=vid) for vid in video_ids]
login(driver)
with django_db_blocker.unblock():
me = UserPreferences.objects.get(user__username=test_username)
# creating ratings
feature = VIDEO_FIELDS[0]
other_values = {k: 50 for k in VIDEO_FIELDS if k != feature}
with django_db_blocker.unblock():
ExpertRating.objects.create(video_1=videos[0],
video_2=videos[1],
**other_values,
**{feature: 0},
user=me) # left is better
ExpertRating.objects.create(video_1=videos[1],
video_2=videos[2],
**other_values,
**{feature: 0},
user=me) # left is better
ExpertRating.objects.create(video_1=videos[2],
video_2=videos[0],
**other_values,
**{feature: 0},
user=me) # left is better
open_more_menu(driver)
WebDriverWait(driver, TIME_WAIT).until(
EC.visibility_of_element_located((By.ID, 'inconsistencies_menu')))
driver.find_element_by_id('inconsistencies_menu').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'inconsistency')))
incons = driver.find_elements_by_class_name('inconsistency')
assert len(incons) > 0
for inc in incons:
vids = inc.get_attribute('id').split('_')
assert len(vids) == 2
assert all([v in video_ids for v in vids])
incons[0].find_element_by_class_name('inconsistency_slider')
set_slider_value(
driver,
slider=incons[0].find_element_by_class_name('inconsistency_slider'),
value=100)
WebDriverWait(driver, TIME_WAIT).until(
EC.element_to_be_clickable((By.CLASS_NAME, 'inconsistency_submit')))
driver.find_element_by_class_name('inconsistency_submit').click()
driver.refresh()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_all_inconsistencies')))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.ID, 'id_inconsistencies_not_loading')))
incons = driver.find_elements_by_class_name('inconsistency')
assert not incons
with django_db_blocker.unblock():
assert ExpertRatingSliderChanges.objects.filter(
context='INC').count() > 0
logout(driver)
def test_mention(driver, django_db_blocker):
login(driver)
with django_db_blocker.unblock():
video_id = create_test_video()
domain = EmailDomain.objects.create(status=EmailDomain.STATUS_ACCEPTED,
domain="@" +
random_alphanumeric() + ".com")
ve = VerifiableEmail.objects.create(
user=UserInformation.objects.get(user__username=test_username),
email="aba" + domain.domain,
is_verified=True)
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')
# setting the video ID
elem.clear()
elem.send_keys(video_id, Keys.HOME)
if elem.get_attribute('value') != video_id:
elem.send_keys(3 * [Keys.DELETE])
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, f'comment_editor_{video_id}_undefined')))
# sending the comment
editor = driver.find_element_by_class_name(
f'comment_editor_{video_id}_undefined')
editor.find_element_by_class_name('public-DraftEditor-content').send_keys(
'@' + test_username)
# selecting the mention suggestion
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'rdw-suggestion-option')))
elems = driver.find_elements_by_class_name('rdw-suggestion-option')
elems = [x for x in elems if test_username in x.text]
assert len(elems) == 1
WebDriverWait(driver, TIME_WAIT).until(EC.visibility_of(elems[0]))
elems[0].click()
action = webdriver.common.action_chains.ActionChains(driver)
action.move_to_element_with_offset(elems[0], elems[0].rect['width'] / 2,
elems[0].rect['height'] / 2)
action.click()
action.perform()
WebDriverWait(driver,
TIME_WAIT).until(EC.invisibility_of_element(elems[0]))
driver.find_elements_by_class_name(
f'comment_editor_submit_{video_id}_undefined')[0].click()
with django_db_blocker.unblock():
assert get_object_with_timeout(VideoComment, video__video_id=video_id)
# going to mentions...
driver.find_element_by_id('personal_info_menu').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_mentions')))
driver.find_element_by_id('id_mentions').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'class_li_comment_mention')))
assert len(
driver.find_elements_by_class_name('class_li_comment_mention')) == 1
logout(driver)
with django_db_blocker.unblock():
Video.objects.filter(video_id=video_id).delete()
ve.delete()
def test_thank_unthank(driver, django_db_blocker):
with django_db_blocker.unblock():
video_id = create_test_video()
video = Video.objects.get(video_id=video_id)
video_id1 = create_test_video()
video1 = Video.objects.get(video_id=video_id1)
domain = EmailDomain.objects.create(status=EmailDomain.STATUS_ACCEPTED,
domain="@" +
random_alphanumeric() + ".com")
# creating a certified user with ratings of the video
other_user = DjangoUser.objects.create_user(
username=random_alphanumeric(), is_active=True)
oup = UserPreferences.objects.create(user=other_user)
oui = UserInformation.objects.create(user=other_user)
ExpertRating.objects.create(user=oup, video_1=video, video_2=video1)
ve = VerifiableEmail.objects.create(user=oui,
email="aba" + domain.domain,
is_verified=True)
login(driver)
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')
# setting the video ID
elem.clear()
elem.send_keys(video_id, Keys.HOME)
if elem.get_attribute('value') != video_id:
elem.send_keys(3 * [Keys.DELETE])
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, f'id_{video_id}_thank')))
driver.find_element_by_id(f'id_{video_id}_thank').click()
with django_db_blocker.unblock():
assert get_object_with_timeout(
VideoRatingThankYou,
video__video_id=video_id,
thanks_from__user__username=test_username,
thanks_to__user__username=other_user.username)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, f'id_{video_id}_unthank')))
driver.find_element_by_id(f'id_{video_id}_unthank').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, f'id_{video_id}_thank')))
with django_db_blocker.unblock():
assert VideoRatingThankYou.objects.filter(
video__video_id=video_id,
thanks_from__user__username=test_username,
thanks_to__user__username=other_user.username).count() == 0
logout(driver)
with django_db_blocker.unblock():
Video.objects.filter(video_id=video_id).delete()
Video.objects.filter(video_id=video_id1).delete()
ve.delete()
other_user.delete()
def test_comments(driver, django_db_blocker):
# creating a video
with django_db_blocker.unblock():
video_id = create_test_video()
login(driver)
open_more_menu(driver)
with django_db_blocker.unblock():
UserInformation.objects.filter(user__username=test_username).update(
comment_anonymously=False)
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')
# setting the video ID
elem.clear()
elem.send_keys(video_id, Keys.HOME)
if elem.get_attribute('value') != video_id:
elem.send_keys(3 * [Keys.DELETE])
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, f'comment_editor_{video_id}_undefined')))
# sending the comment
editor = driver.find_element_by_class_name(
f'comment_editor_{video_id}_undefined')
editor.find_element_by_class_name('public-DraftEditor-content').send_keys(
'sdf')
driver.find_elements_by_class_name(
f'comment_editor_submit_{video_id}_undefined')[0].click()
# checking results
with django_db_blocker.unblock():
comment = get_object_with_timeout(VideoComment,
video__video_id=video_id,
parent_comment=None)
assert comment.comment == "<p>sdf</p>"
assert not comment.anonymous
cid = VideoComment.objects.filter(video__video_id=video_id).get().id
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, f'comment_{cid}_reply')))
# replying to a comment
driver.find_element_by_class_name(f'comment_{cid}_reply').click()
driver.find_element_by_class_name(
f'comment_editor_{video_id}_{cid}').find_element_by_class_name(
'public-DraftEditor-content').send_keys('aba')
driver.find_elements_by_class_name(
f'comment_editor_submit_{video_id}_{cid}')[0].click()
with django_db_blocker.unblock():
subcid = get_object_with_timeout(VideoComment,
video__video_id=video_id,
parent_comment__id=cid).id
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, f'comment_{subcid}_reply')))
# replying to a reply anonymously
driver.find_element_by_class_name(f'comment_{subcid}_reply').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, f'comment_editor_{video_id}_{subcid}')))
driver.find_element_by_class_name(
f'comment_editor_{video_id}_{subcid}').find_element_by_class_name(
'public-DraftEditor-content').send_keys('zzzaaa')
checkbox = driver.find_element_by_class_name(
f'anonymous_comment_checkbox_class_{video_id}_{subcid}')
if not checkbox.find_element_by_tag_name('input').get_property('checked'):
checkbox.click()
driver.find_elements_by_class_name(
f'comment_editor_submit_{video_id}_{subcid}')[0].click()
with django_db_blocker.unblock():
assert get_object_with_timeout(
VideoComment, video__video_id=video_id,
parent_comment__id=cid).comment == '<p>aba</p>'
subsubc = get_object_with_timeout(VideoComment,
video__video_id=video_id,
parent_comment_id=subcid)
assert subsubc.anonymous
assert subsubc.comment == '<p>zzzaaa</p>'
# editing the subcomment
with django_db_blocker.unblock():
ecid = get_object_with_timeout(VideoComment,
video__video_id=video_id,
parent_comment__id=cid).id
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, f'comment_{ecid}_edit')))
driver.find_element_by_class_name(f'comment_{ecid}_edit').click()
elem = driver.find_element_by_class_name(
f'comment_editor_cid_{ecid}').find_element_by_class_name(
'public-DraftEditor-content')
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, f'comment_editor_cid_{ecid}_editing')))
elem.click()
elem.send_keys('xyz')
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, f'comment_{ecid}_save_edits')))
driver.find_element_by_class_name(f'comment_{ecid}_save_edits').click()
with django_db_blocker.unblock():
assert get_object_with_timeout(
VideoComment, video__video_id=video_id,
parent_comment__id=cid).comment.strip() == '<p>xyzaba</p>'
# comment markers
with django_db_blocker.unblock():
assert VideoComment.objects.filter(
video__video_id=video_id,
parent_comment__id=cid).get().votes_plus == 0
driver.find_element_by_class_name(f'vote_plus_comment_{ecid}').click()
with django_db_blocker.unblock():
assert VideoComment.objects.filter(
video__video_id=video_id,
parent_comment__id=cid).get().votes_plus == 1
driver.find_element_by_class_name(f'vote_plus_comment_{ecid}').click()
with django_db_blocker.unblock():
assert VideoComment.objects.filter(
video__video_id=video_id,
parent_comment__id=cid).get().votes_plus == 0
logout(driver)
def test_create_view_reports(driver, django_db_blocker):
# creating a video
with django_db_blocker.unblock():
video_id = create_test_video()
login(driver)
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_elements_by_tag_name('input')[0]
elem.clear()
elem.send_keys(video_id, Keys.HOME)
if elem.get_attribute('value') != video_id:
elem.send_keys(3 * [Keys.DELETE])
print("target id", video_id)
assert elem.get_attribute('value') == video_id
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'button_video_reports')))
# going to reports page
driver.find_element_by_class_name('button_video_reports').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'report_explanation')))
assert not driver.find_elements_by_class_name('video_report_one_item')
checked = {k: np.random.choice([True, False]) for k in VIDEO_REPORT_FIELDS}
for k in VIDEO_REPORT_FIELDS:
checkbox = driver.find_element_by_class_name(f'report_{k}_checkbox')
if checked[k]:
checkbox.click()
assert checkbox.find_element_by_tag_name('input').get_property(
'checked') == checked[k]
driver.find_element_by_class_name(
'report_explanation').find_element_by_tag_name('textarea').send_keys(
"Test explanation")
driver.find_element_by_class_name('report_submit').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_report_submission_ok')))
driver.refresh()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'video_report_one_item')))
assert len(
driver.find_elements_by_class_name('video_report_one_item')) == 1
with django_db_blocker.unblock():
report = VideoReports.objects.get(video__video_id=video_id)
assert report.explanation == "Test explanation"
for k in VIDEO_REPORT_FIELDS:
assert checked[k] == getattr(report, k)
driver.refresh()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'report_explanation')))
# REPORT EDITING
checked_old = checked
checked = {k: np.random.choice([True, False]) for k in VIDEO_REPORT_FIELDS}
for k in VIDEO_REPORT_FIELDS:
checkbox = driver.find_element_by_class_name(f'report_{k}_checkbox')
if checked_old[k] != checked[k]:
checkbox.click()
assert checkbox.find_element_by_tag_name('input').get_property(
'checked') == checked[k]
elem = driver.find_element_by_class_name(
'report_explanation').find_element_by_tag_name('textarea')
elem.send_keys(" II")
driver.find_element_by_class_name('report_submit').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_report_submission_ok')))
driver.refresh()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'report_explanation')))
assert len(
driver.find_elements_by_class_name('video_report_one_item')) == 1
with django_db_blocker.unblock():
report = VideoReports.objects.get(video__video_id=video_id)
assert report.explanation == "Test explanation II"
for k in VIDEO_REPORT_FIELDS:
assert checked[k] == getattr(report, k)
logout(driver)
def test_filters(driver, django_db_blocker):
login(driver)
ui_button = driver.find_element_by_id('user_interface')
ui_button.click()
unique_substr = str(uuid1())
# creating videos
with django_db_blocker.unblock():
video_ids = [create_test_video() for _ in range(3)]
videos = [Video.objects.get(video_id=vid) for vid in video_ids]
for v in videos:
v.name = unique_substr + " " + v.name
for f in VIDEO_FIELDS:
setattr(v, f, 1e10)
v.save()
videos[0].duration = datetime.timedelta(minutes=18)
videos[0].views = 9999
videos[0].publication_date = datetime.datetime.now(
) - datetime.timedelta(days=1)
videos[0].language = 'en'
videos[0].save()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'search_phrase')))
# setting search field
search_phrase_field = driver.find_element_by_id('search_phrase')
search_phrase_field.clear()
search_phrase_field.send_keys(unique_substr)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_search_not_loading')))
# can get all videos
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')))
target_classname = f'video_card_id_{video_ids[-1]}'
print(video_ids, video_ids[-1], target_classname)
WebDriverWait(driver, TIME_WAIT * 5).until(
EC.presence_of_element_located((By.CLASS_NAME, target_classname)))
videos_out = [
x for video_id in video_ids for x in
driver.find_elements_by_class_name(f'video_card_id_{video_id}')
]
print(videos_out)
assert len(videos_out) == len(videos)
# target search options
values = {
'Minimum Duration': '15 min',
'Maximum Duration': '30 min',
'Minimum Number of Views': '0 views',
'Maximum Number of Views': '10k views',
'Publication Date': 'Last month',
'Language': 'English'
}
# opening search options
driver.find_element_by_class_name('search_options').click()
# setting options
for key, value in values.items():
select_options(driver, key, value)
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')))
target_classname = f'video_card_id_{video_ids[0]}'
print(video_ids, target_classname)
WebDriverWait(driver, TIME_WAIT * 5).until(
EC.presence_of_element_located((By.CLASS_NAME, target_classname)))
# now will only see 1 video
videos_out = [
x for video_id in video_ids for x in
driver.find_elements_by_class_name(f'video_card_id_{video_id}')
]
assert len(videos_out) == 1
logout(driver)
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_add_delete(driver, django_db_blocker):
"""Add/delete videos to/from rate later."""
login(driver)
n_videos = 15
limit = 5
with django_db_blocker.unblock():
up = UserPreferences.objects.get(user__username=test_username)
video_ids = [create_test_video() for _ in range(n_videos)]
videos = [Video.objects.get(video_id=vid) for vid in video_ids]
vrls = [VideoRateLater.objects.create(user=up, video=v) for v in videos]
vrls_reverse = vrls[::-1]
print("Going to the rate later page")
expert_interface_btn = driver.find_element_by_id('rate_later_menu')
expert_interface_btn.click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'class_rate_later_list')))
# should get 5 "remove from rate later" buttons
offset = 0
for v in vrls_reverse[offset:offset + limit]:
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, f'id_{v.video.video_id}_remove_rate_later')))
# removing the first one
driver.find_element_by_id(f'id_{vrls_reverse[0].video.video_id}_remove_rate_later').click()
# waiting until the 'add' button appears
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID,
f'id_{vrls_reverse[0].video.video_id}_rate_later')))
# checking that there is no corresponding vrl
with django_db_blocker.unblock():
assert VideoRateLater.objects.filter(video=vrls_reverse[0].video,
user=up).count() == 0
# adding to Rate Later again
driver.find_element_by_id(f'id_{vrls_reverse[0].video.video_id}_rate_later').click()
# waiting until the 'remove' button appears
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID,
f'id_{vrls_reverse[0].video.video_id}_remove_rate_later')))
# checking that there is a corresponding entry
with django_db_blocker.unblock():
assert VideoRateLater.objects.filter(video=vrls_reverse[0].video,
user=up).count() == 1
# clicking on the 'next' button
driver.find_element_by_id('id_rate_later_next').click()
# waiting for videos...
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'class_rate_later_list')))
# verifying the new list
offset = 5
for v in vrls_reverse[offset:offset + limit]:
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, f'id_{v.video.video_id}_remove_rate_later')))
# going back
driver.find_element_by_id('id_rate_later_prev').click()
# waiting for videos...
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.CLASS_NAME, 'class_rate_later_list')))
# should get 5 "remove from rate later" buttons, like before
offset = 0
for v in vrls_reverse[offset:offset + limit]:
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, f'id_{v.video.video_id}_remove_rate_later')))
logout(driver)
with django_db_blocker.unblock():
for v in videos:
v.delete()
def create_toy_data(django_db_blocker, driver,
n_users=10, n_videos=10,
n_ratings=10):
"""Create a random database."""
with django_db_blocker.unblock():
users = [DjangoUser.objects.create_user(
username=random_alphanumeric(), is_active=True)
for u in range(n_users)]
video_ids = [create_test_video() for v in range(n_videos)]
# creating user preferences and user informations
login(driver)
logout(driver)
# creating email domains
status_to_domain = {EmailDomain.STATUS_ACCEPTED: "@accepted.com",
EmailDomain.STATUS_REJECTED: "@rejected.com",
EmailDomain.STATUS_PENDING: "@pending.com"}
with django_db_blocker.unblock():
for status, domain in status_to_domain.items():
EmailDomain.objects.create(domain=domain, status=status)
# obtaining user information/user preferences
with django_db_blocker.unblock():
ups = [UserPreferences.objects.get(user__username=u.username)
for u in users]
uis = [UserInformation.objects.get(user__username=u.username)
for u in users]
# setting show_my_profile and show_online_presence to random values
with django_db_blocker.unblock():
for ui in uis:
ui.show_my_profile = np.random.rand() > 0.5
ui.show_online_presence = np.random.rand() > 0.5
# filling in user informations
with django_db_blocker.unblock():
for ui in uis:
# filling online presence
for field in UserInformation.ONLINE_FIELDS:
domain = UserInformation._domain_startswith.get(field, "mydomain.com")
setattr(ui, field, f"https://{domain}/{random_alphanumeric()}")
# filling personal data
for field in UserInformation.PROFILE_FIELDS:
setattr(ui, field, random_alphanumeric())
# filling in protected attributes
protected_map = {
'birth_year': 1990,
'gender': 'Male',
'nationality': 'Swiss',
'residence': 'Switzerland',
'race': 'Latino or Hispanic',
'political_affiliation': 'Centrist',
'religion': 'Atheist',
'degree_of_political_engagement': 'Light',
'moral_philosophy': 'Utilitatian'
}
for key, val in protected_map.items():
setattr(ui, key, val)
ui.save()
# assigning random emails
with django_db_blocker.unblock():
for ui in uis:
domain = np.random.choice(list(status_to_domain.values()))
email = f"{random_alphanumeric()}{domain}"
verified = np.random.rand() > 0.8
VerifiableEmail.objects.create(email=email, user=ui, is_verified=verified)
# creating random ratings
with django_db_blocker.unblock():
for up in ups:
for _ in range(n_ratings):
fields = {}
for f in VIDEO_FIELDS:
fields[f] = np.random.rand() * 100
fields[f + "_weight"] = np.random.rand() + 1
vid1 = np.random.choice(video_ids)
vid2 = np.random.choice(video_ids)
v1 = Video.objects.get(video_id=vid1)
v2 = Video.objects.get(video_id=vid2)
try:
ExpertRating.objects.create(user=up, video_1=v1, video_2=v2, **fields)
except IntegrityError:
print("Duplicate random comparison (OK)")
pass
# assigning random privacy settings
with django_db_blocker.unblock():
for up in ups:
for video_id in video_ids:
if np.random.rand() > 0.5:
continue
public = np.random.rand() > 0.8
VideoRatingPrivacy.objects.create(
video=Video.objects.get(video_id=video_id),
user=up, is_public=public)
def test_representative(driver, django_db_blocker):
# creating 2 videos
video_ids = []
with django_db_blocker.unblock():
for _ in range(2):
video_ids.append(create_test_video())
videos = [Video.objects.get(video_id=vid) for vid in video_ids]
login(driver)
with django_db_blocker.unblock():
me = UserPreferences.objects.get(user__username=test_username)
# creating ratings
feature = VIDEO_FIELDS[0]
other_values = {k: 50 for k in VIDEO_FIELDS if k != feature}
with django_db_blocker.unblock():
ExpertRating.objects.create(video_1=videos[0],
video_2=videos[1],
**other_values,
**{feature: 0},
user=me) # left is better
VideoRating.objects.create(video=videos[0],
user=me,
**{feature: 0},
**other_values)
VideoRating.objects.create(video=videos[1],
user=me,
**{feature: 100},
**other_values)
open_more_menu(driver)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'representative_menu')))
driver.find_element_by_id('representative_menu').click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'representative_debug_slider')))
sliders = driver.find_elements_by_class_name('representative_debug_slider')
assert len(sliders) == 1
set_slider_value(driver, slider=sliders[0], value=100)
driver.find_element_by_class_name('representative_debug_submit').click()
driver.refresh()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.ID, 'id_representative_interface_all')))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located(
(By.ID, 'id_representative_not_loading')))
sliders = driver.find_elements_by_class_name('representative_debug_slider')
assert len(sliders) == 0
with django_db_blocker.unblock():
assert ExpertRatingSliderChanges.objects.filter(
context='DIS').count() > 0
logout(driver)
