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)
management.call_command('update_index', interactive=False)
#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')
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_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)
management.call_command('update_index', interactive=False)
#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 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_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)
}
self.data_utils.upload_subs(self.user, **data)
#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(self.user, **data)
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 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(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 setUpClass(cls):
super(TestCaseUntimedText, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.user = UserFactory.create(username = '******')
cls.video_pg = video_page.VideoPage(cls)
cls.editor_pg = editor_page.EditorPage(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 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')),
'complete': int(complete)
}
cls.data_utils.upload_subs(cls.user, **data)
#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.user, **data)
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.user, **data)
#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.user, **data)
cls.video_pg.open_video_page(cls.video.video_id)
def create_tv_with_original_subs(cls, lc, user, team, complete=True):
sub_file = 'apps/webdriver_testing/subtitle_data/Timed_text.en.srt'
video = VideoUrlFactory().video
tv = TeamVideoFactory.create(
team=team,
video=video,
added_by=user)
data = {'language_code': lc,
'video': video.pk,
'primary_audio_language_code': lc,
'draft': open(sub_file),
'is_complete': complete,
'complete': int(complete),
}
cls.data_utils.upload_subs(user, **data)
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(self.user, **data)
self.video_pg.open_video_page(video.video_id)
self.assertEqual('English', self.menu.visible_menu_text())
def create_video(self, **kwargs):
v = VideoUrlFactory.create(**kwargs)
return v.video