def test_change_team_member(self):
with assert_invalidates_model_cache(self.team):
member = TeamMemberFactory(team=self.team)
with assert_invalidates_model_cache(self.team):
member.save()
with assert_invalidates_model_cache(self.team):
member.delete()
def test_change_membership_narrowing(self):
admin = TeamMemberFactory(team=self.team)
member = TeamMemberFactory(team=self.team)
with assert_invalidates_model_cache(self.team):
narrowing = MembershipNarrowing.objects.create(member=member,
language='en',
added_by=admin)
with assert_invalidates_model_cache(self.team):
narrowing.save()
with assert_invalidates_model_cache(self.team):
narrowing.delete()
def test_toggle_following_video(self):
"""Turn on and off following for a video
"""
follower = UserFactory()
self.video_pg.log_in(follower.username, 'password')
self.video_pg.open_video_page(self.video.video_id)
with assert_invalidates_model_cache(self.video):
self.video_pg.toggle_follow()
self.assertEqual(self.FOLLOWING, self.video_pg.follow_text())
with assert_invalidates_model_cache(self.video):
self.video_pg.toggle_follow()
self.assertEqual(self.NOT_FOLLOWING, self.video_pg.follow_text())
def test_remove_team_only(self):
"""Remove video from team but NOT site.
Must be the team owner to get the team vs. site dialog.
"""
owner = TeamMemberFactory(team=self.team).user
self.videos_tab.log_in(owner.username, 'password')
tv = VideoFactory(title='team only annihilation', )
TeamVideoFactory.create(team=self.team, video=tv)
management.call_command('update_index', interactive=False)
self.video_pg.open_video_page(tv.video_id)
#Search for the video in team videos and remove it.
self.videos_tab.open_videos_tab(self.team.slug)
self.videos_tab.search(tv.title)
with assert_invalidates_model_cache(tv):
self.videos_tab.remove_video(video=tv.title,
removal_action='team-removal')
time.sleep(2)
#Update the solr index
management.call_command('update_index', interactive=False)
#Verify video no longer in teams
self.assertEqual(tv.get_team_video(), None)
self.videos_tab.search(tv.title)
self.assertEqual(self.videos_tab.NO_VIDEOS_TEXT,
self.videos_tab.search_no_result())
#Verify video is present on the site
watch_pg = watch_page.WatchPage(self)
watch_pg.open_watch_page()
results_pg = watch_pg.basic_search(tv.title)
self.assertTrue(results_pg.search_has_results())
def test_leave_contributor(self):
"""A contributor can leave a team.
"""
self.team_dir_pg.log_in(self.member.username, 'password')
with assert_invalidates_model_cache(self.team):
self.team_dir_pg.leave_team(self.team.slug)
self.assertTrue(self.team_dir_pg.leave_team_successful())
def test_add_task_invalidates_video_cache(self):
team_video = TeamVideoFactory()
with assert_invalidates_model_cache(team_video.video):
task = Task(team=team_video.team,
team_video=team_video,
language='en',
type=Task.TYPE_IDS['Translate'])
task.save(update_team_video_index=False)
def setUpClass(cls):
super(TestCaseUnpublishLast, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.editor_pg = editor_page.EditorPage(cls)
cls.tasks_tab = TasksTab(cls)
cls.video_pg = video_page.VideoPage(cls)
cls.watch_pg = watch_page.WatchPage(cls)
cls.user = UserFactory.create()
cls.owner = UserFactory.create()
cls.team = TeamMemberFactory.create(team__workflow_enabled=True,
team__translate_policy=20, #any team
team__subtitle_policy=20, #any team
team__task_assign_policy=10, #any team
user = cls.owner,
).team
cls.workflow = WorkflowFactory(team = cls.team,
autocreate_subtitle=True,
autocreate_translate=True,
approve_allowed = 10, # manager
review_allowed = 10, # peer
)
lang_list = ['en', 'ru', 'pt-br', 'de', 'sv']
for language in lang_list:
TeamLangPrefFactory.create(team=cls.team, language_code=language,
preferred=True)
cls.admin = TeamMemberFactory(role="ROLE_ADMIN",team=cls.team).user
cls.contributor = TeamMemberFactory(team=cls.team).user
cls.subs_dir = os.path.join(os.getcwd(), 'apps', 'webdriver_testing',
'subtitle_data')
cls.video, cls.tv = cls.create_source_with_multiple_revisions()
translation = os.path.join(cls.subs_dir, 'Timed_text.sv.dfxp')
#Upload subs - sv - incomplete, de - reviewed, ru - complete needs review
cls.logger.info("""Uploading subs to get tasks in various stages: """)
cls.logger.info("""
sv: translation started, incomplete
ru: translation submitted, needs review
de: translation reviewed, needs approve
pt-br: not started
""")
cls._upload_lang(cls.video, translation, 'sv', cls.contributor)
cls._upload_lang(cls.video, translation, 'de', cls.contributor,
complete=True)
cls.data_utils.complete_review_task(cls.tv, 20, cls.admin)
cls._upload_lang(cls.video, translation, 'ru', cls.contributor,
complete=True)
cls.logger.info('Setting visibility override on v3 to private')
cls.en = cls.video.subtitle_language('en')
en_v3 = cls.en.get_tip(full=True)
with assert_invalidates_model_cache(cls.video):
en_v3.visibility_override = 'private'
en_v3.save()
cls.tasks_tab.open_page('teams/%s/tasks/?assignee=anyone'
% cls.team.slug)
def test_new_translation(self):
"""Upload a new translation.
"""
with assert_invalidates_model_cache(self.tv):
test_file = 'Timed_text.sv.dfxp'
sub_file = os.path.join(self.subs_data_dir, test_file)
sc = self._upload_and_verify(self.tv, sub_file, 'Swedish', 'sv')
self.assertEqual(sc, 72)
def test_assign_manager(self):
"""Asign a manager with no restrictions.
Verify the display of the roles in the members tab.
"""
self.members_tab.log_in(self.admin.username, 'password')
self.members_tab.member_search(self.promoted_manager.username)
with assert_invalidates_model_cache(self.team):
self.members_tab.edit_user(role="Manager")
self.members_tab.member_search(self.promoted_manager.username)
self.assertEqual(self.members_tab.user_role(), 'Manager')
def test_url_post(self):
"""Add an additional new url. """
video = VideoFactory()
new_url = 'http://unisubs.example.com/newurl.mp4'
url = '/api/videos/%s/urls/' % video.video_id
data = {'url': new_url}
with assert_invalidates_model_cache(video):
r = self._post(url, data)
r = self._get(url)
urls = [x['url'] for x in r]
self.logger.info(r)
self.assertIn(video.get_video_url(), urls)
self.assertIn(new_url, urls)
def test_no_over_aggressive_deletion(self):
"""Deleting language for 1 video does not affect other video languages.
"""
#Create first video and video subtitles
video1, tv1 = self._add_team_video()
self._upload_subtitles(video1,
'en',
self.rev1,
self.member,
complete=True)
self.data_utils.complete_review_task(tv1, 20, self.admin)
self.data_utils.complete_approve_task(tv1, 20, self.admin)
self._upload_translation(video1, 'sv', self.sv, self.member)
self.data_utils.complete_review_task(tv1, 20, self.admin)
self.data_utils.complete_approve_task(tv1, 20, self.admin)
#Create second video and incomplete sv subtitles
video2, tv2 = self._add_team_video()
self._upload_subtitles(video2,
'en',
self.rev1,
self.member,
complete=True)
self.data_utils.complete_review_task(tv2, 20, self.admin)
self.data_utils.complete_approve_task(tv2, 20, self.admin)
self._upload_translation(video2,
'sv',
self.sv,
self.member,
complete=False)
self.video_lang_pg.log_in(self.admin.username, 'password')
self.video_lang_pg.page_refresh()
self.video_lang_pg.open_video_lang_page(video1.video_id, 'en')
#Delete English subtitle language + Swedish for video 1
with assert_invalidates_model_cache(video1):
self.video_lang_pg.delete_subtitle_language(['Swedish'])
self.tasks_tab.open_page('teams/{0}/tasks/?team_video={1}'
'&assignee=anyone&lang=sv'.format(
self.team.slug, tv2.pk))
self.assertTrue(
self.tasks_tab.task_present('Translate Subtitles into Swedish',
video2.title))
def test_video_comment_message(self):
"""Message sent on video comment to followers has link to comments tab.
"""
mail.outbox = []
self.video_pg.open_comments()
with assert_invalidates_model_cache(self.video):
self.video_pg.add_comment('This is a great video')
tasks.send_video_comment_notification.apply()
msg = str(mail.outbox[-1].message())
self.assertIn('This is a great video', msg)
self.assertIn(
'<a href="{0}{1}?tab=comments">'.format(
self.base_url[:-1], self.video.get_absolute_url()), msg)
def test_post_publish_edit(self):
"""Edit title in approve, video title updated after publish """
video = TeamVideoFactory(team=self.team,
video__primary_audio_language_code='en',
).video
self._create_subs(video, 'en', self.member, complete=True)
orig_title = video.title
self.logger.info(video.title)
new_title = 'this is a new title'
self.tasks_tab.log_in(self.manager.username, 'password')
self.data_utils.complete_review_task(video.get_team_video(), 20, self.manager)
self.data_utils.complete_approve_task(video.get_team_video(), 20, self.manager)
self.tasks_tab.log_in(self.admin.username, 'password')
self.video_lang_pg.open_video_lang_page(video.video_id, 'en')
self.video_lang_pg.edit_subtitles()
self.editor_pg.edit_title(new_title)
with assert_invalidates_model_cache(video):
self.editor_pg.collab_action('Publish')
self.assertEqual(new_title, self.video_pg.video_title())
def test_url_delete(self):
"""Delete a url.
"""
video = VideoFactory()
new_url = 'http://unisubs.example.com/newurl.mp4'
url = '/api/videos/%s/urls/' % video.video_id
data = { 'url': new_url }
r = self._post(url, data)
update_url = '/api/videos/{0}/urls/{1}/'.format(video.video_id, r['id'])
with assert_invalidates_model_cache(video):
self.client.force_authenticate(self.user)
response = self.client.delete(update_url, data)
self.logger.info(response)
r = self._get(url)
urls = [x['url'] for x in r]
self.logger.info(r)
self.assertIn(video.get_video_url(), urls)
self.assertNotIn(new_url, urls)
def test_join_authenticated(self):
"""Logged in user can join an open team.
"""
user = UserFactory.create()
self.a_team_pg.log_in(user.username, 'password')
self.a_team_pg.open_team_page(self.team.slug)
with assert_invalidates_model_cache(self.team):
self.a_team_pg.join()
self.modal.select_spoken_languages(self.default_langs)
# Verify team page displays
self.assertTrue(self.a_team_pg.is_team(self.team.name))
# Verify the join button is no longer displayed
self.assertFalse(self.a_team_pg.join_exists())
#Verify the user is a member of team in db.
team = TeamFactory.build(pk=self.team.pk)
self.assertEqual(user.username, team.users.get(username=user.username).username)
def test_switch_primary_url(self):
"""Use PUT request to switch primary url
PUT /api2/partners/videos/[video-id]/urls/[url-id]/
"""
#Post an additional url to the video
video = VideoFactory()
new_url = 'http://unisubs.example.com/newurl.mp4'
url = '/api/videos/%s/urls/' % video.video_id
data = {'url': new_url}
r = self._post(url, data)
#Set the new url as as primary
put_url = '/api/videos/{0}/urls/{1}/'.format(video.video_id, r['id'])
put_data = {'url': new_url, 'primary': True}
with assert_invalidates_model_cache(video):
self.client.force_authenticate(self.user)
response = self.client.put(put_url, put_data)
response.render()
r = (json.loads(response.content))
self.assertEqual(new_url, video.get_video_url())
def test_join_apply(self):
"""User can apply to join team and is a member after approval.
"""
test_joiner = UserFactory.create()
self.a_team_pg.log_in(test_joiner.username, 'password')
with assert_invalidates_model_cache(self.team):
self.a_team_pg.open_team_page(self.team.slug)
self.a_team_pg.apply()
#Check that language selection choices are present
self.a_team_pg.application_languages()
self.a_team_pg.submit_application()
user_app = ApplicationFactory.build(
team=self.team,
user=test_joiner,
)
user_app.approve(
author = self.team_owner.username,
interface = "web UI")
self.members_tab.open_members_page(self.team.slug)
self.members_tab.member_search(test_joiner.username)
self.assertEqual(self.members_tab.user_role(), 'Contributor')
def test_change_team(self):
with assert_invalidates_model_cache(self.team):
self.team.save()
def test_user_language_change_invalidates_cache(self):
user = UserFactory()
with assert_invalidates_model_cache(user):
user_lang = UserLanguage.objects.create(user=user, language='en')
with assert_invalidates_model_cache(user):
user_lang.delete()
def test_remove_from_team(self):
team_video = TeamVideoFactory(video=self.video)
with assert_invalidates_model_cache(self.video):
team_video.delete()
def test_move_team(self):
team_video = TeamVideoFactory(video=self.video)
other_team = TeamFactory()
with assert_invalidates_model_cache(self.video):
team_video.move_to(other_team)
def test_add_to_team(self):
with assert_invalidates_model_cache(self.video):
TeamVideoFactory(video=self.video)
