def test_notify_contributor(self):
"""Subtitle contributor gets an email when new revision added.
"""
video = VideoUrlFactory().video
self.video_pg.open_video_page(video.video_id)
self.video_pg.log_in(self.user.username, 'password')
rev1 = os.path.join(self.subs_path, 'rev1.dfxp')
self.video_pg.open_video_page(video.video_id)
self.video_pg.upload_subtitles('English', rev1)
sl = video.subtitle_language('en')
v1 = sl.get_tip().id
sl.clear_tip_cache()
user2 = UserFactory.create()
self.video_pg.log_in(user2.username, 'password')
rev2 = os.path.join(self.subs_path, 'rev2.dfxp')
self.video_pg.open_video_page(video.video_id)
mail.outbox = []
self.video_pg.upload_subtitles('English', rev2)
email_to = mail.outbox[-1].to
msg = str(mail.outbox[-1].message())
#self.logger.info("MESSAGE: %s" % msg)
v2 = sl.get_tip().id
diffing_page = ('videos/diffing/{0}/{1}/'.format(v2, v1))
self.video_pg.open_page(diffing_page)
self.assertIn(diffing_page, msg)
self.assertIn(self.user.email, email_to)
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.
"""
self.videos_tab.log_in(self.team_owner.username, 'password')
tv = VideoUrlFactory(video__title='team only annihilation').video
TeamVideoFactory.create(team=self.team,
video=tv,
added_by=self.manager_user)
#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)
self.videos_tab.remove_video(video=tv.title,
removal_action='team-removal')
#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_notify__language_follower(self):
"""Language follower gets an email when new revision added.
"""
video = VideoUrlFactory().video
self.video_pg.open_video_page(video.video_id)
self.video_pg.log_in(self.user.username, 'password')
rev1 = os.path.join(self.subs_path, 'rev1.dfxp')
self.video_pg.open_video_page(video.video_id)
self.video_pg.upload_subtitles('English', rev1)
follower = UserFactory.create(email='*****@*****.**')
self.video_language_pg.open_video_lang_page(video.video_id, 'en')
self.video_pg.log_in(follower.username, 'password')
self.video_pg.page_refresh()
self.video_pg.toggle_follow()
mail.outbox = []
self.video_pg.log_in(self.user.username, 'password')
rev2 = os.path.join(self.subs_path, 'rev2.dfxp')
self.video_pg.open_video_page(video.video_id)
self.video_pg.upload_subtitles('English', rev2)
email_to = mail.outbox[-1].to
msg = str(mail.outbox[-1].message())
self.logger.info("MESSAGE: %s" % msg)
self.assertIn(follower.email, email_to)
urlstart = 'http://' + Site.objects.get_current().domain
lang = video.subtitle_language('en')
# combine whitespace and replace it with " " for easier string
# comparisons
msg = ' '.join(msg.split())
correct_message = string.Template(
'<b><a href="${lang_url}">${lang_name} subtitles</a></b> '
'to video <b><a href="${video_url}">${video_name}</a></b> '
'were changed by <b><a href="${user_url}">${user_name}</a></b>. '
'These changes went live immediately. 33% of the timing was '
'changed.').substitute({
'lang_url':
urlstart + rmlocale(lang.get_absolute_url()),
'lang_name':
lang.get_language_code_display(),
'video_url':
urlstart + rmlocale(video.get_absolute_url()),
'video_name':
video.title_display(),
'user_url':
urlstart + rmlocale(self.user.get_absolute_url()),
'user_name':
self.user.username,
})
self.assertIn(correct_message, msg)
def create_video(self, **kwargs):
try:
v = VideoUrlFactory(**kwargs).video
except IntegrityError:
v, _ = Video.get_or_create_for_url(video_url=kwargs['url'])
self.logger.info('Video: %s' % v.video_id)
return v
def test_notify__video_follower_revisions(self):
"""Video follower gets an email when new revision added.
"""
video = VideoUrlFactory().video
follower = UserFactory.create(email='*****@*****.**')
self.video_pg.open_video_page(video.video_id)
self.video_pg.log_in(follower.username, 'password')
self.video_pg.page_refresh()
self.video_pg.toggle_follow()
mail.outbox = []
self.video_pg.open_video_page(video.video_id)
self.video_pg.log_in(self.user.username, 'password')
self.video_pg.page_refresh()
rev1 = os.path.join(self.subs_path, 'rev1.dfxp')
self.video_pg.open_video_page(video.video_id)
self.video_pg.upload_subtitles('English', rev1)
rev2 = os.path.join(self.subs_path, 'rev2.dfxp')
self.video_pg.open_video_page(video.video_id)
self.video_pg.upload_subtitles('English', rev2)
self.video_pg.page_refresh()
email_to = mail.outbox[-1].to
msg = str(mail.outbox[-1].message())
self.logger.info("MESSAGE: %s" % msg)
self.assertIn(follower.email, email_to)
def test_notify__video_follower_initial(self):
"""Video follower gets an email when first revision of subtitles added.
"""
self.skipTest('needs https://unisubs.sifterapp.com/issues/2220 fixed')
video = VideoUrlFactory().video
follower = UserFactory.create(email='*****@*****.**')
self.video_pg.open_video_page(video.video_id)
self.video_pg.log_in(follower.username, 'password')
self.video_pg.page_refresh()
self.video_pg.toggle_follow()
self.assertEqual(self.FOLLOWING, self.video_pg.follow_text())
mail.outbox = []
self.video_pg.open_video_page(video.video_id)
self.video_pg.log_in(self.user.username, 'password')
self.video_pg.page_refresh()
rev1 = os.path.join(self.subs_path, 'rev1.dfxp')
self.video_pg.open_video_page(video.video_id)
self.video_pg.upload_subtitles('English', rev1)
self.assertEqual(1, len(mail.outbox))
email_to = mail.outbox[-1].to
msg = str(mail.outbox[-1].message())
self.logger.info("MESSAGE: %s" % msg)
self.assertIn(follower.email, email_to)
def test_no_primary_audio_lang(self):
"""Language list displays when no subs for primary audio lang exists.
"""
vid = VideoUrlFactory().video
#Upload en, primary audio = de
complete = True
data = {
'language_code': 'en',
'video': vid.pk,
'primary_audio_language_code': 'de',
'draft': open(os.path.join(self.subs_dir, 'Timed_text.en.srt')),
'is_complete': complete,
'complete': int(complete)
}
user_auth = dict(username=self.user.username, password='******')
self.data_utils.upload_subs(vid, data, user_auth)
#Upload sv, forked
data = {
'language_code': 'sv',
'video': vid.pk,
'draft': open(os.path.join(self.subs_dir, 'Timed_text.sv.dfxp')),
'is_complete': complete,
'complete': int(complete)
}
self.data_utils.upload_subs(vid, data, user_auth)
self.video_pg.open_video_page(vid.video_id)
_, en_status = self.video_pg.language_status('English')
self.assertIn('status-complete', en_status,
'ref: https://unisubs.sifterapp.com/issues/2350')
def setUpClass(cls):
super(TestCaseProjectsAddEdit, cls).setUpClass()
#management.call_command('flush', interactive=False)
cls.data_utils = data_helpers.DataHelpers()
cls.videos_tab = videos_tab.VideosTab(cls)
cls.team_owner = UserFactory.create()
cls.logger.info('setup: Creating team Video Test')
cls.team = TeamMemberFactory.create(user=cls.team_owner).team
cls.logger.info('setup: Adding a team with 2 projects.')
cls.project1 = TeamProjectFactory.create(team=cls.team)
cls.project2 = TeamProjectFactory.create(team=cls.team)
test_videos = [
'jaws.mp4', 'Birds_short.oggtheora.ogg', 'fireplace.mp4'
]
cls.videos_list = []
for vid in test_videos:
video_url = 'http://qa.pculture.org/amara_tests/%s' % vid[0]
tv = VideoUrlFactory(url=video_url, video__title=vid).video
v = TeamVideoFactory(video=tv,
team=cls.team,
added_by=cls.team_owner,
project=cls.project2).video
cls.videos_list.append(v)
management.call_command('update_index', interactive=False)
cls.videos_tab.open_videos_tab(cls.team.slug)
cls.videos_tab.log_in(cls.team_owner.username, 'password')
cls.project1_page = ('teams/{0}/videos/?project={1}'.format(
cls.team.slug, cls.project1.slug))
cls.project2_page = ('teams/{0}/videos/?project={1}'.format(
cls.team.slug, cls.project2.slug))
def test_remove__site(self):
"""Remove video from team and site, total destruction!
Must be the team owner to get the team vs. site dialog.
"""
self.videos_tab.log_in(self.team_owner.username, 'password')
#Create a team video for removal.
tv = VideoUrlFactory(video__title='total destruction').video
TeamVideoFactory.create(team=self.team,
video=tv,
added_by=self.manager_user)
#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)
self.videos_tab.remove_video(video=tv.title,
removal_action='total-destruction')
#Verify video no longer in teams
self.videos_tab.search(tv.title)
self.assertEqual(self.videos_tab.NO_VIDEOS_TEXT,
self.videos_tab.search_no_result())
self.videos_tab.open_videos_tab(self.team.slug)
#Verify video no longer on site
watch_pg = watch_page.WatchPage(self)
watch_pg.open_watch_page()
self.logger.info('searching for the test video %s' % tv.title)
results_pg = watch_pg.basic_search(tv.title)
self.assertTrue(results_pg.search_has_no_results())
def test_version__existing_translation(self):
"""On upload, create a new version and replace existing translation.
Uploaded subs replace the existing version even if the existing
version has subs created from it.
"""
tv = VideoUrlFactory(url='http://www.example.com/3.mp4').video
video_list = self.data_utils.create_videos_with_fake_subs()
test_file = 'Untimed_text.srt'
sub_file = os.path.join(self.subs_data_dir, test_file)
self.video_pg.open_video_page(tv.video_id)
message = self.video_pg.upload_subtitles('Russian', sub_file)
self.assertEqual(self.video_pg.UPLOAD_SUCCESS_TEXT, message)
subtitle_lang = tv.subtitle_language('ru')
subtitle_lang.clear_tip_cache()
self.assertEqual(2, subtitle_lang.get_tip().version_number)
def test_upload__additional_translation(self):
"""Uploading a set of subs in a new language.
New language is created as a new version.
"""
tv = VideoUrlFactory().video
video_list = self.data_utils.create_videos_with_fake_subs()
test_file = 'Untimed_text.srt'
sub_file = os.path.join(self.subs_data_dir, test_file)
self.video_pg.open_video_page(tv.video_id)
message = self.video_pg.upload_subtitles('Swedish', sub_file)
self.assertEqual(self.video_pg.UPLOAD_SUCCESS_TEXT, message)
self.video_pg.page_refresh()
subtitle_lang = tv.subtitle_language('sv')
subtitle_lang.clear_tip_cache()
self.assertEqual(1, subtitle_lang.get_tip().version_number)
self.assertEqual(43, subtitle_lang.get_subtitle_count())
def test__version__overwrite_existing(self):
"""On upload, create a new version and replace original transcription.
Uploaded subs replace the existing version of original lang text.
"""
tv = VideoUrlFactory(url='http://www.example.com/4.mp4').video
video_list = self.data_utils.create_videos_with_fake_subs()
test_file = 'Untimed_text.srt'
sub_file = os.path.join(self.subs_data_dir, test_file)
self.video_pg.open_video_page(tv.video_id)
message = self.video_pg.upload_subtitles('Arabic', sub_file)
self.assertEqual(self.video_pg.UPLOAD_SUCCESS_TEXT, message)
sub_lang = tv.subtitle_language('ar')
self.video_pg.page_refresh()
subtitle_lang = tv.subtitle_language('ar')
subtitle_lang.clear_tip_cache()
self.assertEqual(2, subtitle_lang.get_tip().version_number)
def setUpClass(cls):
super(TestCaseViewSubtitles, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.menu = unisubs_menu.UnisubsMenu(cls)
cls.user = UserFactory.create()
cls.video_pg = video_page.VideoPage(cls)
cls.video_language_pg = video_language_page.VideoLanguagePage(cls)
cls.subs_dir = os.path.join(os.getcwd(), 'apps', 'webdriver_testing',
'subtitle_data')
cls.video = VideoUrlFactory().video
#Upload original language de
complete = True
data = {
'language_code': 'de',
'video': cls.video.pk,
'primary_audio_language_code': 'de',
'draft': open(os.path.join(cls.subs_dir, 'Timed_text.en.srt')),
'is_complete': complete,
'complete': int(complete)
}
user_auth = dict(username=cls.user.username, password='******')
cls.data_utils.upload_subs(cls.video, data, user_auth)
#Upload sv, translated from de, complete
data = {
'language_code': 'sv',
'video': cls.video.pk,
'translated_from': 'de',
'draft': open(os.path.join(cls.subs_dir, 'Timed_text.sv.dfxp')),
'is_complete': complete,
'complete': int(complete)
}
cls.data_utils.upload_subs(cls.video, data, user_auth)
complete = False
#Upload ar, translated from de, incomplete
data = {
'language_code': 'ar',
'video': cls.video.pk,
'draft': open(os.path.join(cls.subs_dir, 'Timed_text.ar.xml')),
'is_complete': complete,
'complete': int(complete)
}
cls.data_utils.upload_subs(cls.video, data, user_auth)
#Upload hu, translated from sv, incomplete
data = {
'language_code': 'hu',
'video': cls.video.pk,
'translated_from': 'sv',
'draft': open(os.path.join(cls.subs_dir, 'Timed_text.hu.ssa')),
'is_complete': complete,
'complete': int(complete)
}
cls.data_utils.upload_subs(cls.video, data, user_auth)
cls.video_pg.open_video_page(cls.video.video_id)
def test_default__subtitler_following_language(self):
"""Subtitler is set to following for language contributed.
"""
self.video_pg.log_in(self.user, 'password')
tv = VideoUrlFactory().video
sub_file = os.path.join(self.subs_data_dir, 'Untimed_text.dfxp')
self.video_pg.open_video_page(tv.video_id)
self.video_pg.upload_subtitles('English', sub_file)
self.video_language_pg.open_video_lang_page(tv.video_id, 'en')
self.assertEqual(self.FOLLOWING, self.video_language_pg.follow_text())
def test_default__subtitler_not_following_video(self):
"""Not following is setting for Video after contribution subtitles.
"""
self.video_pg.log_in(self.user, 'password')
tv = VideoUrlFactory().video
sub_file = os.path.join(self.subs_data_dir, 'Untimed_text.dfxp')
self.video_pg.open_video_page(tv.video_id)
self.video_pg.upload_subtitles('English', sub_file)
self.video_pg.open_video_page(tv.video_id)
self.assertEqual(self.NOT_FOLLOWING, self.video_pg.follow_text())
def setUpClass(cls):
super(TestCaseTimedText, cls).setUpClass()
cls.user = UserFactory.create(username='******')
cls.video_pg = video_page.VideoPage(cls)
cls.video_lang_pg = video_language_page.VideoLanguagePage(cls)
cls.test_video = VideoUrlFactory().video
cls.subs_data_dir = os.path.join(os.getcwd(), 'apps',
'webdriver_testing', 'subtitle_data')
cls.video_pg.open_video_page(cls.test_video.video_id)
cls.video_pg.log_in(cls.user.username, 'password')
cls.video_pg.set_skiphowto()
def _create_tv_with_original_subs(cls, user, team, complete=True):
member_creds = dict(username=user.username, password='******')
sub_file = os.path.join(cls.subs_data_dir, 'Timed_text.en.srt')
video = VideoUrlFactory().video
tv = TeamVideoFactory.create(team=team, video=video, added_by=user)
data = {
'language_code': 'en',
'video': video.pk,
'primary_audio_language_code': 'en',
'draft': open(sub_file),
'is_complete': complete,
'complete': int(complete),
}
cls.data_utils.upload_subs(video, data, member_creds)
return video, tv
def test_subs_with_markdown(self):
"""Subtitles are available for subtitles with markdown formatting.
"""
sub_file = os.path.join(self.subs_data_dir, 'subs_with_markdown.dfxp')
video = VideoUrlFactory().video
data = {
'language_code': 'en',
'video': video.pk,
'primary_audio_language_code': 'en',
'draft': open(sub_file),
'is_complete': True,
'complete': 1
}
self.data_utils.upload_subs(video, data)
self.video_pg.open_video_page(video.video_id)
self.assertEqual('English', self.menu.visible_menu_text())
def _add_video_and_subs(self, sub_file, lang_code, title):
"""Create the test videos and add subtitles to it.
"""
video = VideoUrlFactory(
url='http://example.unisubs.com/download-test.mp4',
video__title=title).video
data = {
'language_code': lang_code,
'video': video.pk,
'primary_audio_language_code': lang_code,
'draft': open(sub_file),
'is_complete': True,
'complete': 1
}
self.data_utils.upload_subs(video, data)
return video
def _create_video_with_complete_transcript(self, team, owner):
sub_file = os.path.join(os.getcwd(), 'apps', 'webdriver_testing',
'subtitle_data', 'Timed_text.en.srt')
member_creds = self._create_team_member(team)
video = VideoUrlFactory().video
tv = TeamVideoFactory.create(
team=team,
video=video,
added_by=owner)
orig_data = {'language_code': 'en',
'video': video.pk,
'primary_audio_language_code': 'en',
'draft': open(sub_file),
'is_complete': True,
'complete': 1,
}
self.data_utils.upload_subs(video, orig_data, member_creds)
return video, tv
def _create_video_with_complete_transcript(self, team, owner):
sub_file = os.path.join(os.getcwd(), 'apps', 'webdriver_testing',
'subtitle_data', 'Timed_text.en.srt')
member = TeamMemberFactory(team=team, role='ROLE_CONTRIBUTOR').user
video = VideoUrlFactory().video
tv = TeamVideoFactory.create(
team=team,
video=video,
added_by=owner)
data = {
'language_code': 'en',
'video': video,
'visibility': 'private',
'complete': True,
'committer': member
}
self.data_utils.add_subs(**data)
return video, tv
