def setUpClass(cls):
super(TestCaseSubmittable, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.video_pg = video_page.VideoPage(cls)
cls.video_language_pg = video_language_page.VideoLanguagePage(cls)
cls.user = UserFactory.create(username='******')
cls.create_modal = dialogs.CreateLanguageSelection(cls)
cls.sub_editor = subtitle_editor.SubtitleEditor(cls)
cls.unisubs_menu = unisubs_menu.UnisubsMenu(cls)
td = {'url': ('http://qa.pculture.org/amara_tests/' 'Birds_short.mp4')}
cls.test_video = cls.data_utils.create_video(**td)
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()
#Open the video page and sync the first 3 subs
cls.video_pg.add_subtitles()
cls.create_modal.create_original_subs('English', 'English')
cls.logger.info('typing subs')
cls.typed_subs = cls.sub_editor.type_subs()
cls.sub_editor.continue_to_next_step()
cls.logger.info('syncing subs')
cls.sub_editor.sync_subs(len(cls.typed_subs) + 2)
cls.timing_list = cls.sub_editor.sub_timings()
cls.sub_editor.save_and_exit()
def test_url__delete_last(self):
"""Can not delete the last (only) url.
If this is the only URL for a video, the request will fail.
A video must have at least one URL.
"""
video_id = self.test_video.video_id
expected_url = self.test_video.get_video_url()
#Get a list of the current urls
url_part = 'videos/%s/urls/' % video_id
status, response = self.data_utils.api_get_request(self.user, url_part)
url_objects = response['objects']
id_list = []
for url in url_objects:
id_list.append(url['id'])
for url_id in sorted(id_list, reverse=True):
url_part = 'videos/%s/urls/' % url_id
update_url = 'videos/{0}/urls/{1}/'.format(video_id, url_id)
status, response = self.data_utils.delete_api_request(
self.user, update_url)
#Open the video page on the ui - for the verification screenshot
video_pg = video_page.VideoPage(self)
video_pg.open_video_page(video_id)
self.assertEqual(expected_url, self.test_video.get_video_url())
def setUp(self):
super(TestCaseIncomplete, self).setUp()
self.data_utils = data_helpers.DataHelpers()
self.video_pg = video_page.VideoPage(self)
self.user = UserFactory.create(username='******')
self.create_modal = dialogs.CreateLanguageSelection(self)
self.sub_editor = subtitle_editor.SubtitleEditor(self)
self.unisubs_menu = unisubs_menu.UnisubsMenu(self)
td = {
'url': ('http://qa.pculture.org/amara_tests/'
'Birds_short.webmsd.webm')
}
self.test_video = self.data_utils.create_video(**td)
self.video_pg.open_video_page(self.test_video.video_id)
self.video_pg.log_in(self.user.username, 'password')
self.video_pg.set_skiphowto()
#Open the video page and sync the first 3 subs
self.video_pg.add_subtitles()
self.create_modal.create_original_subs('English', 'English')
self.logger.info('typing subs')
self.typed_subs = self.sub_editor.type_subs()
self.sub_editor.continue_to_next_step()
self.logger.info('syncing subs')
self.sub_editor.sync_subs(len(self.typed_subs) + 2)
self.timing_list = self.sub_editor.sub_timings()
self.sub_editor.continue_to_next_step()
self.logger.info('continue to description screen')
self.sub_editor.continue_to_next_step()
self.logger.info('continue to review screen')
self.sub_editor.continue_to_next_step()
def setUpClass(cls):
super(TestCaseLeftSide, cls).setUpClass()
fixt_data = [
'apps/webdriver_testing/fixtures/editor_auth.json',
'apps/webdriver_testing/fixtures/editor_videos.json',
'apps/webdriver_testing/fixtures/editor_subtitles.json'
]
for f in fixt_data:
management.call_command('loaddata', f, verbosity=0)
cls.logger.info("""Default Test Data loaded from fixtures
English, source primary v2 -> v6
v1 -> deleted
Chinese v1 -> v3
v3 {"zh-cn": 2, "en": 6}
Danish v1 --> v4
v4 {"en": 5, "da": 3}
Swedish v1 --> v3 FORKED
v3 {"sv": 2}
v1 --> private
Turkish (tr) v1 incomplete {"en": 5}
""")
cls.editor_pg = editor_page.EditorPage(cls)
cls.data_utils = data_helpers.DataHelpers()
cls.video_pg = video_page.VideoPage(cls)
cls.user = UserFactory.create()
cls.video_pg.open_page('auth/login/', alert_check=True)
cls.video_pg.log_in(cls.user.username, 'password')
def test_url__put_primary(self):
"""Verify video urls for a particular video are listed.
PUT /api2/partners/videos/[video-id]/urls/[url-id]/
"""
#Post an additional url to the video
video_id = self.test_video.video_id
video_url = self.test_video.get_video_url()
url_data = {'url': 'http://unisubs.example.com/newurl.mp4'}
url_part = 'videos/%s/urls/' % video_id
status, response = self.data_utils.post_api_request(
self.user, url_part, url_data)
#Put an updated url on the video and set it as primary
put_url = 'videos/{0}/urls/{1}/'.format(video_id, response['id'])
put_data = {
'url': 'http://unisubs.example.com/newerurl.mp4',
'primary': True
}
status, response = self.data_utils.put_api_request(
self.user, put_url, put_data)
self.assertEqual('http://unisubs.example.com/newerurl.mp4',
response['url'])
video_pg = video_page.VideoPage(self)
video_pg.open_video_page(video_id)
self.assertEqual('http://unisubs.example.com/newerurl.mp4',
self.test_video.get_video_url())
def setUpClass(cls):
super(TestCaseViewSubtitles, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.video_pg = video_page.VideoPage(cls)
cls.user = UserFactory.create()
cls.owner = UserFactory.create()
cls.basic_team = TeamMemberFactory.create(
team__workflow_enabled=False,
team__translate_policy=20, #any team
team__subtitle_policy=20, #any team
user=cls.owner,
).team
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
)
cls.contributor = TeamContributorMemberFactory(team=cls.team).user
cls.subs_dir = os.path.join(os.getcwd(), 'apps', 'webdriver_testing',
'subtitle_data')
cls.rev1 = os.path.join(cls.subs_dir, 'Timed_text.en.srt')
cls.rev2 = os.path.join(cls.subs_dir, 'Timed_text.rev2.en.srt')
de = os.path.join(cls.subs_dir, 'Timed_text.rev3.en.srt')
cls.sv = os.path.join(cls.subs_dir, 'Timed_text.sv.dfxp')
#Create en source language 2 revisions - approved.
cls.video, cls.tv = cls._add_team_video()
cls._upload_subtitles(cls.video,
'en',
cls.rev1,
cls.contributor,
complete=False)
cls._upload_subtitles(cls.video, 'en', cls.rev2, cls.contributor)
cls.data_utils.complete_review_task(cls.tv, 20, cls.owner)
cls.data_utils.complete_approve_task(cls.tv, 20, cls.owner)
#Add sv translation, reviewed
cls._upload_translation(cls.video, 'sv', cls.sv, cls.contributor)
cls.data_utils.complete_review_task(cls.tv, 20, cls.owner)
#Add de translation complete waiting review
cls._upload_translation(cls.video, 'de', cls.sv, cls.contributor)
#Add ru translation, incomplete.
cls._upload_translation(cls.video,
'ru',
cls.sv,
cls.contributor,
complete=False)
def setUpClass(cls):
super(TestCaseRollbackRevision, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.video_lang_pg = video_language_page.VideoLanguagePage(cls)
cls.diffing_pg = diffing_page.DiffingPage(cls)
cls.video_pg = video_page.VideoPage(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.team_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 = TeamAdminMemberFactory(team=cls.team).user
cls.contributor = TeamMemberFactory(team=cls.team).user
cls.subs_dir = os.path.join(os.getcwd(), 'apps', 'webdriver_testing',
'subtitle_data')
def setUpClass(cls):
super(TestCaseRevisionNotifications, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.user = UserFactory.create()
cls.video_pg = video_page.VideoPage(cls)
cls.diffing_pg = diffing_page.DiffingPage(cls)
cls.video_language_pg = video_language_page.VideoLanguagePage(cls)
cls.subs_path = os.path.dirname(os.path.abspath(__file__))
def setUpClass(cls):
super(TestCaseRevisionEdits, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.video_lang_pg = video_language_page.VideoLanguagePage(cls)
cls.video_pg = video_page.VideoPage(cls)
cls.user1 = UserFactory.create()
cls.user2 = UserFactory.create()
cls.subs_dir = os.path.join(os.getcwd(), 'apps', 'webdriver_testing',
'subtitle_data')
def setUpClass(cls):
super(TestCaseSubtitles, 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_data_dir = os.path.join(os.getcwd(), 'apps',
'webdriver_testing', 'subtitle_data')
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 setUpClass(cls):
super(TestCaseEntryExit, cls).setUpClass()
fixt_data = [
'apps/webdriver_testing/fixtures/editor_auth.json',
'apps/webdriver_testing/fixtures/editor_videos.json',
'apps/webdriver_testing/fixtures/editor_subtitles.json'
]
for f in fixt_data:
management.call_command('loaddata', f, verbosity=0)
cls.logger.info("""Default Test Data - loaded from fixtures
English, source primary v2 -> v6
v1 -> deleted
Chinese v1 -> v3
v3 {"zh-cn": 2, "en": 6}
Danish v1 --> v4
v4 {"en": 5, "da": 3}
Swedish v1 --> v3 FORKED
v3 {"sv": 2}
v1 --> private
Turkish (tr) v1 incomplete {"en": 5}
""")
cls.create_modal = dialogs.CreateLanguageSelection(cls)
cls.sub_editor = subtitle_editor.SubtitleEditor(cls)
cls.unisubs_menu = unisubs_menu.UnisubsMenu(cls)
cls.editor_pg = editor_page.EditorPage(cls)
cls.video_pg = video_page.VideoPage(cls)
cls.video_lang_pg = video_language_page.VideoLanguagePage(cls)
cls.tasks_tab = TasksTab(cls)
cls.user = UserFactory.create()
cls.video_pg.open_page('auth/login/')
cls.video_pg.log_in(cls.user.username, 'password')
#Create a workflow enabled team to check review/approve dialog switching.
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.user,
).team
cls.workflow = WorkflowFactory(
team=cls.team,
autocreate_subtitle=True,
autocreate_translate=True,
approve_allowed=10, # manager
review_allowed=10, # peer
)
cls.user = UserFactory.create()
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(TestCaseUploadTranslation, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.user = UserFactory.create(username='******')
cls.video_pg = video_page.VideoPage(cls)
cls.video_language_pg = video_language_page.VideoLanguagePage(cls)
cls.subs_data_dir = os.path.join(os.getcwd(), 'apps',
'webdriver_testing', 'subtitle_data')
cls.video_pg.open_page('videos/create/')
cls.video_pg.log_in(cls.user.username, 'password')
def setUpClass(cls):
super(TestCaseFollowing, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.user = UserFactory.create()
cls.video_pg = video_page.VideoPage(cls)
cls.video_language_pg = video_language_page.VideoLanguagePage(cls)
cls.create_pg = create_page.CreatePage(cls)
cls.create_pg.open_create_page()
cls.video = cls.data_utils.create_video_with_subs()
cls.subs_data_dir = os.path.join(os.getcwd(), 'apps',
'webdriver_testing', 'subtitle_data')
cls.create_pg.open_create_page()
def test_list(self):
"""Verify video urls for a particular video are listed.
GET /api2/partners/videos/[video-id]/urls/
"""
video_id = self.test_video.video_id
video_url = self.test_video.get_video_url()
url_part = 'videos/%s/urls/' % video_id
status, response = self.data_utils.api_get_request(self.user, url_part)
video_pg = video_page.VideoPage(self)
video_pg.open_video_page(video_id)
self.assertEqual(video_url, response['objects'][0]['url'])
def setUpClass(cls):
super(TestCaseNoWorkflow, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.video_lang_pg = video_language_page.VideoLanguagePage(cls)
cls.video_pg = video_page.VideoPage(cls)
cls.user = UserFactory.create()
cls.owner = UserFactory.create()
cls.team = TeamMemberFactory.create(
team__translate_policy=20, #any team
team__subtitle_policy=20, #any team
user=cls.owner,
).team
cls.admin = TeamAdminMemberFactory(team=cls.team).user
cls.contributor = TeamMemberFactory(team=cls.team).user
cls.subs_dir = os.path.join(os.getcwd(), 'apps', 'webdriver_testing',
'subtitle_data')
def test_url__post(self):
"""Add an additional new url.
POST /api2/partners/videos/[video-id]/urls/
"""
video_id = self.test_video.video_id
video_url = self.test_video.get_video_url()
url_data = {'url': 'http://unisubs.example.com/newurl.mp4'}
url_part = 'videos/%s/urls/' % video_id
status, response = self.data_utils.post_api_request(
self.user, url_part, url_data)
vid_url = 'videos/%s' % video_id
status, response = self.data_utils.api_get_request(self.user, vid_url)
video_pg = video_page.VideoPage(self)
video_pg.open_video_page(video_id)
self.assertIn(video_url, response['all_urls'], response)
def setUpClass(cls):
super(TestCaseDraftVideos, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.video_pg = video_page.VideoPage(cls)
cls.video_lang_pg = video_language_page.VideoLanguagePage(cls)
cls.menu = unisubs_menu.UnisubsMenu(cls)
cls.create_modal = dialogs.CreateLanguageSelection(cls)
cls.user = UserFactory(username='******', is_partner=True)
cls.data_utils.create_user_api_key(cls.user)
#Add a team with workflows, tasks and preferred languages
cls.logger.info('setup: Create a team with tasks enabled')
cls.team = TeamMemberFactory.create(
team__workflow_enabled=True,
team__subtitle_policy=20,
team__translate_policy=20,
user=cls.user,
).team
cls.team_workflow = WorkflowFactory(
team=cls.team,
autocreate_subtitle=True,
autocreate_translate=True,
approve_allowed=10,
review_allowed=10,
)
cls.member = TeamContributorMemberFactory.create(
team=cls.team, user=UserFactory(username='******')).user
cls.nonmember = UserFactory()
#Add video to team with draft subtitles
cls.logger.info('Setup: Add video to team with draft subs.')
cls.draft = TeamVideoFactory.create(
team=cls.team,
video=cls.data_utils.create_video(),
added_by=cls.user).video
cls.data_utils.upload_subs(cls.draft,
data=None,
user=dict(username=cls.user.username,
password='******'))
cls.video_pg.open_video_page(cls.draft.video_id)
cls.video_pg.set_skiphowto()
def setUp(self):
super(TestCaseTranscribing, self).setUp()
self.data_utils = data_helpers.DataHelpers()
td = {
'url': ('http://qa.pculture.org/amara_tests/'
'Birds_short.webmsd.webm')
}
self.test_video = self.data_utils.create_video(**td)
self.video_pg = video_page.VideoPage(self)
self.user = UserFactory.create()
self.video_pg.open_video_page(self.test_video.video_id)
self.video_pg.log_in(self.user.username, 'password')
self.video_pg.set_skiphowto()
self.create_modal = dialogs.CreateLanguageSelection(self)
self.sub_editor = subtitle_editor.SubtitleEditor(self)
self.unisubs_menu = unisubs_menu.UnisubsMenu(self)
self.video_pg.log_in(self.user.username, 'password')
self.video_pg.add_subtitles()
self.create_modal.create_original_subs('English', 'English')
self.typed_subs = self.sub_editor.type_subs()
def setUp(self):
super(TestCaseSyncBrowserError, self).setUp()
self.data_utils = data_helpers.DataHelpers()
self.user = UserFactory.create(username='******')
self.create_modal = dialogs.CreateLanguageSelection(self)
self.sub_editor = subtitle_editor.SubtitleEditor(self)
self.unisubs_menu = unisubs_menu.UnisubsMenu(self)
self.video_pg = video_page.VideoPage(self)
self.video_language_pg = video_language_page.VideoLanguagePage(self)
td = {'url': ('http://qa.pculture.org/amara_tests/' 'Birds_short.mp4')}
self.test_video = self.data_utils.create_video(**td)
self.video_pg.open_video_page(self.test_video.video_id)
self.video_pg.log_in(self.user.username, 'password')
self.video_pg.set_skiphowto()
#Open the video page and sync the first 3 subs
self.video_pg.add_subtitles()
self.create_modal.create_original_subs('English', 'English')
self.typed_subs = self.sub_editor.type_subs()
self.sub_editor.continue_to_next_step()
num_synced_subs = 3
self.sub_editor.sync_subs(num_synced_subs)
def setUpClass(cls):
super(TestCaseCenter, cls).setUpClass()
fixt_data = [
'apps/webdriver_testing/fixtures/editor_auth.json',
'apps/webdriver_testing/fixtures/editor_videos.json',
'apps/webdriver_testing/fixtures/editor_subtitles.json'
]
for f in fixt_data:
management.call_command('loaddata', f, verbosity=0)
cls.logger.info("""Default Test Data
video[0]:
English, source primary v2 -> v6
v1 -> deleted
Chinese v1 -> v3
v3 {"zh-cn": 2, "en": 6}
Danish v1 --> v4
v4 {"en": 5, "da": 3}
Swedish v1 --> v3 FORKED
v3 {"sv": 2}
v1 --> private
Turkish (tr) v1 incomplete {"en": 5}
video[1]: No subs - about amara video
video[2]: No subs youtube
video[3]: en original 1 version complete.
video[4]: nl unsynced, not original
""")
cls.editor_pg = editor_page.EditorPage(cls)
cls.data_utils = data_helpers.DataHelpers()
cls.video_pg = video_page.VideoPage(cls)
cls.user = UserFactory.create()
cls.video_pg.open_page('auth/login/')
cls.video_pg.log_in(cls.user.username, 'password')
def setUpClass(cls):
super(TestCaseTranscribe, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.video_pg = video_page.VideoPage(cls)
cls.admin_video_pg = edit_video_page.EditVideoPage(cls)
cls.tasks_tab = TasksTab(cls)
cls.owner = UserFactory.create(username='******')
cls.superuser = UserFactory.create(is_staff=True, is_superuser=True)
cls.transcribe_team = TeamMemberFactory.create(
user = cls.owner,
team__slug = 'ted-transcribe',
team__workflow_enabled=True,
team__name = 'TED Transcribe').team
cls.transcribe_project = TeamProjectFactory.create(
team=cls.transcribe_team,
name='TedTalks',
slug='tedtalks')
WorkflowFactory(team = cls.transcribe_team,
autocreate_subtitle=True,
autocreate_translate=False,
approve_allowed = 20,
review_allowed = 10,
)
cls.member = TeamAdminMemberFactory.create(
team = cls.transcribe_team,
)
entries = [ {
'ted_talkid': 1800,
'ted_duration': '00:14:17',
'summary': 'Stuff about the video',
'ted_speakername': 'Eleanor Longden',
'title': 'The voices in my head',
'links': [ {
'rel': 'enclosure',
'href': 'http://unisubs.example.com/video1800.mp4',
'hreflang': 'en',
}
],
'updated_parsed': time.localtime(10000),
},
{
'ted_talkid': 1801,
'ted_duration': '00:12:17',
'summary': 'Stuff about the video',
'title': 'No speaker name',
'links': [ {
'rel': 'enclosure',
'href': 'http://unisubs.example.com/video1801.mp4',
'hreflang': 'en',
}
],
'updated_parsed': time.localtime(10000)
}
]
for entry in entries:
tasks._parse_entry(cls.transcribe_team, entry,
cls.member, cls.transcribe_project)
cls.video, _ = Video.get_or_create_for_url(
'http://unisubs.example.com/video1800.mp4')
cls.video_pg.open_video_page(cls.video.video_id)
cls.video_pg.log_in('TED', 'password')
def setUpClass(cls):
super(TestCaseUnpublishLast, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.create_modal = dialogs.CreateLanguageSelection(cls)
cls.sub_editor = subtitle_editor.SubtitleEditor(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 = TeamAdminMemberFactory(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)
en_v3.visibility_override = 'private'
en_v3.save()
cls.tasks_tab.open_page('teams/%s/tasks/?lang=all&assignee=anyone' %
cls.team.slug)
def setUpClass(cls):
super(TestCaseTED, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.video_pg = video_page.VideoPage(cls)
cls.video_lang_pg = video_language_page.VideoLanguagePage(cls)
cls.profile_dash_pg = profile_dash_page.ProfileDashPage(cls)
cls.tasks_tab = TasksTab(cls)
cls.dashboard_tab = DashboardTab(cls)
cls.videos_tab = VideosTab(cls)
cls.watch_pg = watch_page.WatchPage(cls)
cls.logger.info("Create TED teams")
cls.owner = UserFactory.create(username='******')
cls.ted_team = TeamMemberFactory.create(
user = cls.owner,
team__slug = 'ted',
team__name = 'TED',
team__workflow_enabled=True).team
cls.ted_project = TeamProjectFactory.create(
team=cls.ted_team,
name='TedTalks',
slug='tedtalks')
WorkflowFactory(team = cls.ted_team,
autocreate_subtitle=True,
autocreate_translate=True,
approve_allowed = 20,
review_allowed = 10,
)
cls.member = TeamAdminMemberFactory.create(
team = cls.ted_team,
)
lang_list = ['en', 'ru', 'pt-br', 'de', 'sv']
for language in lang_list:
TeamLangPrefFactory.create(team=cls.ted_team, language_code=language,
preferred=True)
cls.admin = TeamAdminMemberFactory(team=cls.ted_team).user
cls.data_utils.create_user_api_key(cls.admin)
cls.contributor = TeamMemberFactory(team=cls.ted_team).user
entries = [ {
'ted_talkid': 1806,
'ted_duration': '00:09:03',
'summary': 'Stuff about the video',
'ted_speakername': 'Jinsop Lee',
'title': 'TestVideo1',
'links': [ {
'rel': 'enclosure',
'href': 'http://unisubs.example.com/video1806.mp4',
'hreflang': 'en',
}
],
'updated_parsed': time.localtime(10000)
},
{
'ted_talkid': 1801,
'ted_duration': '00:12:17',
'summary': 'Stuff about the video',
'title': 'NoSpeakerVideo',
'links': [ {
'rel': 'enclosure',
'href': 'http://unisubs.example.com/video1801.mp4',
'hreflang': 'en',
}
],
'updated_parsed': time.localtime(10000)
}
]
for entry in entries:
tasks._parse_entry(cls.ted_team, entry,
cls.member, cls.ted_project)
cls.speaker_video, _ = Video.get_or_create_for_url(
'http://unisubs.example.com/video1806.mp4')
cls.nospeaker_video, _ = Video.get_or_create_for_url(
'http://unisubs.example.com/video1801.mp4')
#Add approved 'en' subs speaker name
speaker_data = { 'speaker-name': 'Santa' }
cls._create_subs(cls.speaker_video, 'en', complete=True, metadata=speaker_data)
cls.data_utils.complete_review_task(cls.speaker_video.get_team_video(),
20, cls.admin)
cls.data_utils.complete_approve_task(cls.speaker_video.get_team_video(),
20, cls.owner)
#Add approved 'sv' translation with speaker name
speaker_data = { 'speaker-name': 'TomTom' }
cls._create_subs(cls.speaker_video, 'sv', True, metadata=speaker_data, title='sv subs title')
cls.data_utils.complete_review_task(cls.speaker_video.get_team_video(),
20, cls.admin)
sv = cls.speaker_video.subtitle_language('sv').get_tip()
sv.update_metadata( { 'speaker-name': 'Jultomten'} )
cls.data_utils.complete_approve_task(cls.speaker_video.get_team_video(),
20, cls.owner)
#Add draft 'de' subs reviewed with speaker name
speaker_data = { 'speaker-name': 'Klaus' }
cls._create_subs(cls.speaker_video, 'de', True, metadata=speaker_data, title='de subs title')
cls.data_utils.complete_review_task(cls.speaker_video.get_team_video(),
20, cls.owner)
#Add ru draft, no speaker name
cls._create_subs(cls.speaker_video, 'ru')
management.call_command('update_index', interactive=False)
cls.dashboard_tab.open_team_page(cls.ted_team.slug)
def setUpClass(cls):
super(TestCaseDeletion, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.video_lang_pg = video_language_page.VideoLanguagePage(cls)
cls.video_pg = video_page.VideoPage(cls)
cls.tasks_tab = TasksTab(cls)
cls.watch_pg = watch_page.WatchPage(cls)
cls.sub_editor = subtitle_editor.SubtitleEditor(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 = TeamAdminMemberFactory(team=cls.team).user
cls.contributor = TeamContributorMemberFactory(team=cls.team).user
cls.subs_dir = os.path.join(os.getcwd(), 'apps', 'webdriver_testing',
'subtitle_data')
cls.rev1 = os.path.join(cls.subs_dir, 'Timed_text.en.srt')
cls.rev2 = os.path.join(cls.subs_dir, 'Timed_text.rev2.en.srt')
cls.sv = os.path.join(cls.subs_dir, 'Timed_text.sv.dfxp')
ru = os.path.join(cls.subs_dir, 'less_lines.ssa')
cls.logger.info("""
Create video with en as primary audio lang.
Subtitle, review and approve.
Translate to:
sv: reviewed
de: complete, needs review
ru: incomplete
Delete Subtitle Language en + sv and de.
""")
#Create en source language 2 revisions - approved.
cls.video, cls.tv = cls._add_team_video()
cls._upload_subtitles(cls.video,
'en',
cls.rev1,
cls.contributor,
complete=False)
cls._upload_subtitles(cls.video, 'en', cls.rev2, cls.contributor)
cls.data_utils.complete_review_task(cls.tv, 20, cls.admin)
cls.data_utils.complete_approve_task(cls.tv, 20, cls.admin)
#Add sv translation, reviewed
cls._upload_translation(cls.video, 'sv', cls.sv, cls.contributor)
cls.data_utils.complete_review_task(cls.tv, 20, cls.admin)
#Add it translation, reviewed
cls._upload_translation(cls.video, 'it', cls.sv, cls.contributor)
cls.data_utils.complete_review_task(cls.tv, 20, cls.admin)
#Add hr translation, needs review
cls._upload_translation(cls.video, 'hr', cls.sv, cls.contributor)
#Add de translation complete waiting review
cls._upload_translation(cls.video, 'de', cls.sv, cls.contributor)
#Add ru translation, incomplete.
cls._upload_translation(cls.video,
'ru',
cls.sv,
cls.contributor,
complete=False)
cls.video_lang_pg.open_video_lang_page(cls.video.video_id, 'en')
cls.video_lang_pg.log_in(cls.owner.username, 'password')
cls.video_lang_pg.page_refresh()
#Delete English subtitle language + Swedish and German
cls.video_lang_pg.delete_subtitle_language(['Swedish', 'German'])
management.call_command('update_index', interactive=False)
management.call_command('update_video_metadata')
