def setUpClass(cls):
super(TestCaseProjectsFilterSort, 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.manager_user = TeamAdminMemberFactory(team=cls.team,
user=UserFactory()).user
cls.logger.info('setup: Adding project one and project two with '
'workflows enabled')
cls.project1 = TeamProjectFactory.create(
team=cls.team,
workflow_enabled=True,
)
cls.project2 = TeamProjectFactory.create(team=cls.team,
workflow_enabled=True)
data = json.load(open('apps/videos/fixtures/teams-list.json'))
videos = _create_videos(data, [])
for video in videos:
TeamVideoFactory.create(team=cls.team,
video=video,
added_by=cls.manager_user,
project=cls.project2)
cls.videos_tab.open_videos_tab(cls.team.slug)
cls.videos_tab.log_in(cls.manager_user.username, 'password')
def setUpClass(cls):
super(TestCaseFilterSort, cls).setUpClass()
#management.call_command('flush', interactive=False)
cls.data_utils = data_helpers.DataHelpers()
cls.logger.info("Create team 'video-test' and add 1 video")
cls.team_owner = UserFactory.create(is_partner=True)
cls.team = TeamMemberFactory.create(user=cls.team_owner).team
cls.manager_user = TeamAdminMemberFactory(team=cls.team,
user=UserFactory()).user
cls.videos_tab = videos_tab.VideosTab(cls)
vidurl_data = {
'url': 'http://www.youtube.com/watch?v=WqJineyEszo',
'video__title': 'X Factor Audition - Stop Looking At My Mom Rap',
'type': 'Y'
}
cls.test_video = cls.data_utils.create_video(**vidurl_data)
cls.data_utils.upload_subs(cls.test_video)
TeamVideoFactory.create(team=cls.team,
video=cls.test_video,
added_by=cls.manager_user)
cls.data_utils.create_user_api_key(cls.team_owner)
videos = cls.data_utils.create_several_team_videos_with_subs(
cls.team, cls.manager_user)
management.call_command('update_index', interactive=False)
def setUp(self):
super(TestCaseAddRemoveEdit, self).setUp()
#management.call_command('flush', interactive=False)
self.data_utils = data_helpers.DataHelpers()
self.logger.info("Create team and add 1 video")
self.team_owner = UserFactory.create()
self.team = TeamMemberFactory.create(user=self.team_owner).team
self.manager_user = TeamAdminMemberFactory(
team=self.team, user=UserFactory(username='******')).user
self.videos_tab = videos_tab.VideosTab(self)
data = {
'url':
'http://www.youtube.com/watch?v=WqJineyEszo',
'video__title': ('X Factor Audition - Stop Looking At My '
'Mom Rap - Brian Bradley'),
'type':
'Y'
}
self.test_video = self.data_utils.create_video(**data)
self.data_utils.upload_subs(self.test_video)
TeamVideoFactory.create(team=self.team,
video=self.test_video,
added_by=self.manager_user)
self.videos_tab.open_videos_tab(self.team.slug)
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_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_pagination__admin(self):
"""Check number of videos displayed per page for team admin.
"""
for x in range(50):
TeamVideoFactory.create(team=self.limited_access_team,
video=VideoFactory.create(),
added_by=self.team_owner)
self.videos_tab.log_in(self.team_owner.username, 'password')
self.videos_tab.open_videos_tab(self.limited_access_team.slug)
self.assertEqual(8, self.videos_tab.num_videos())
def test_pagination__user(self):
"""Check number of videos displayed per page for team contributor.
"""
contributor = UserFactory(username='******')
for x in range(50):
TeamVideoFactory.create(team=self.limited_access_team,
video=VideoFactory.create(),
added_by=self.team_owner)
self.videos_tab.log_in(contributor.username, 'password')
self.videos_tab.open_videos_tab(self.limited_access_team.slug)
self.assertEqual(16, self.videos_tab.num_videos())
def setUpClass(cls):
super(TestCaseActivity, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.user = UserFactory.create(is_partner=True)
#create an open team with description text and 2 members
cls.open_team = TeamMemberFactory.create(
team__name="A1 Waay Cool team",
team__slug='a1-waay-cool-team',
team__description='this is the coolest, most creative team ever',
user=cls.user).team
TeamMemberFactory.create(team=cls.open_team, user=UserFactory.create())
TeamVideoFactory.create(team=cls.open_team, added_by=cls.user)
def setUpClass(cls):
super(TestCaseTeamsPage, cls).setUpClass()
cls.COOL_TEAM_NAME = "A1 Waay Cool team"
#CREATE A USER
cls.cool_user = UserFactory.create(username='******',
password='******')
cls.logger.info("creating some teams for testing")
#create 5 open teams
for x in range(5):
TeamMemberFactory.create(team__name='my team ' + str(x),
team__slug='my-team-' + str(x),
user__username='******' + str(x),
user__password='******')
#create an open team with description text and 2 members
cls.team = TeamMemberFactory.create(
team__name="A1 Waay Cool team",
team__slug='a1-waay-cool-team',
team__description='this is the coolest, most creative team ever',
user__username='******',
user__password='******').team
TeamMemberFactory.create(team=cls.team, user=cls.cool_user)
TeamVideoFactory.create(team=cls.team, added_by=cls.cool_user)
#create an application team with 3 members and 5 videos
cls.app_team = TeamMemberFactory.create(
team__name='the application-only team',
team__slug='the-application-only-team',
team__membership_policy=1,
user__username='******',
user__password='******').team
TeamMemberFactory.create(team=cls.app_team, user=UserFactory.create())
TeamMemberFactory.create(team=cls.app_team, user=cls.cool_user)
for x in range(5):
TeamVideoFactory.create(team=cls.app_team, added_by=cls.cool_user)
#create 1 private team
cls.priv_team = TeamMemberFactory.create(
team__name='my own private idaho ',
team__slug='private-idaho',
team__membership_policy=1,
team__is_visible=False,
user__username='******',
user__password='******').team
cls.teams_dir_pg = TeamsDirPage(cls)
cls.a_team_pg = ATeamPage(cls)
def setUpClass(cls):
super(TestCaseTeamsResource, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.user = UserFactory.create(is_partner=True)
cls.private_user = UserFactory.create(username='******')
cls.data_utils.create_user_api_key(cls.user)
cls.logger.info('setup: creating team data')
#create 3 open teams
for x in range(3):
TeamMemberFactory.create(
team__name='my team ' + str(x),
team__slug='my-team-' + str(x),
user__username='******' + str(x),
)
#create an open team with description text and 2 members
cls.open_team = TeamMemberFactory.create(
team__name="A1 Waay Cool team",
team__slug='a1-waay-cool-team',
team__description='this is the coolest, most creative team ever',
user__username='******',
).team
TeamMemberFactory.create(team=cls.open_team, user=cls.user)
TeamVideoFactory.create(team=cls.open_team, added_by=cls.user)
#create an application team with 3 members and 5 videos
app_team = TeamMemberFactory.create(
team__name='the application-only team',
team__slug='the-application-only-team',
team__membership_policy=1,
user__username='******',
).team
TeamMemberFactory.create(team=app_team, user=UserFactory.create())
TeamMemberFactory.create(team=app_team, user=cls.user)
for x in range(5):
TeamVideoFactory.create(team=app_team, added_by=cls.user)
#create 1 private team
cls.priv_team = TeamMemberFactory.create(
team__name='my own private idaho',
team__slug='private-idaho',
team__membership_policy=1,
team__is_visible=False,
user=cls.private_user).team
#Open to the teams page so you can see what's there.
cls.teams_dir_pg = TeamsDirPage(cls)
cls.teams_dir_pg.open_teams_page()
def create_several_team_videos_with_subs(self, team, teamowner, data=None):
"""Uses the helper data from the apps.videos.fixtures to create data.
The test vidoes are then assigned to the specified team.
Returns the list of video.
"""
if not data:
testdata = simplejson.load(
open('apps/videos/fixtures/teams-list.json'))
else:
testdata = simplejson.load(open(data))
videos = _create_videos(testdata, [])
for video in videos:
TeamVideoFactory.create(team=team, video=video, added_by=teamowner)
return videos
def _old_to_new_sv_review(self):
self.logger.info('creating video and adding to team')
video = Video.objects.all()[0]
member = TeamMemberFactory(team=self.team).user
#Add video to team and create a review task
tv = TeamVideoFactory(team=self.team, added_by=self.user, video=video)
translate_task = TaskFactory.build(type=20,
team=self.team,
team_video=tv,
language='sv',
assignee=member)
self.logger.info('complete the translate task')
translate_task.new_subtitle_version = translate_task.get_subtitle_version(
)
translate_task.save()
task = translate_task.complete()
self.logger.info('perform review task to open in old editor')
self.tasks_tab.open_tasks_tab(self.team.slug)
self.tasks_tab.log_in(member.username, 'password')
self.tasks_tab.open_tasks_tab(self.team.slug)
self.tasks_tab.open_page('teams/{0}/tasks/?team_video={1}'
'&assignee=anyone&lang=sv'.format(
self.team.slug, tv.pk))
self.tasks_tab.perform_and_assign_task('Review Swedish Subtitles',
video.title)
self.sub_editor.continue_to_next_step()
self.logger.info('open in new editor')
self.sub_editor.open_in_beta_editor()
return video, tv
self.editor_pg.exit()
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_start__translation(self):
"""Member starts translation from any task in “Videos that need your
help”.
"""
self.logger.info('setup: Setting task policy to all team members')
self.team.task_assign_policy = 20
self.team.video_policy = 1
self.team.save()
video = self.non_team_video
self.data_utils.upload_subs(video)
tv = TeamVideoFactory(video=video,
team=self.team,
added_by=self.polly_glott)
self.create_modal = dialogs.CreateLanguageSelection(self)
#Login user and go to team dashboard page
self.logger.info(
'Polly Glott logs in and goes to team dashboard page.')
self.dashboard_tab.log_in(self.polly_glott.username, 'password')
self.dashboard_tab.set_skiphowto()
self.dashboard_tab.open_team_page(self.team.slug)
self.dashboard_tab.click_lang_task('Short Birds MP4',
'Translate Russian')
self.create_modal.lang_selection()
self.assertEqual('Adding a New Translation',
self.sub_editor.dialog_title())
def setUp(self):
super(TestCaseLangSuggestion, self).setUp()
self.data_utils = data_helpers.DataHelpers()
self.sub_editor = subtitle_editor.SubtitleEditor(self)
self.create_modal = dialogs.CreateLanguageSelection(self)
self.dashboard_tab = dashboard_tab.DashboardTab(self)
self.user = UserFactory(username='******', is_partner=True)
self.data_utils.create_user_api_key(self.user)
#Add a team with workflows, tasks and preferred languages
self.logger.info('setup: Create a team with tasks enabled')
self.team = TeamMemberFactory.create(
team__name='Tasks Enabled',
team__slug='tasks-enabled',
team__workflow_enabled=True,
user=self.user,
).team
self.team_workflow = WorkflowFactory(
team=self.team,
autocreate_subtitle=True,
autocreate_translate=True,
)
self.team_workflow.review_allowed = 10
self.team_workflow.save()
self.logger.info('setup: Add some preferred languages to the team.')
lang_list = ['en', 'ru', 'pt-br', 'fr', 'de', 'es']
for language in lang_list:
TeamLangPrefFactory.create(team=self.team,
language_code=language,
preferred=True)
#Add some videos with various languages required.
self.logger.info('setup: Add some videos and set primary audio lang.')
d = {
'url': 'http://qa.pculture.org/amara_tests/Birds_short.mp4',
'video__title': 'Short Birds MP4',
'video__primary_audio_language_code': 'en'
}
self.non_team_video = self.data_utils.create_video(**d)
test_videos = [('jaws.mp4', 'fr'), ('trailer.webm', 'en')]
self.vid_obj_list = []
for vid in test_videos:
vidurl_data = {
'url': ('http://qa.pculture.org/amara_tests/%s' % vid[0]),
'video__title': vid[0]
}
video = self.data_utils.create_video(**vidurl_data)
if vid[1] is not None:
video.primary_audio_language_code = vid[1]
video.save()
self.vid_obj_list.append(video)
team_video = TeamVideoFactory(video=video,
team=self.team,
added_by=self.user)
def test_sort__most_subtitles(self):
"""Sort on the project page by most subtitles.
"""
project_page = 'teams/{0}/videos/?project={1}'.format(
self.team.slug, self.project2.slug)
data2 = json.load(
open('apps/webdriver_testing/check_teams/lots_of_subtitles.json'))
videos2 = _create_videos(data2, [])
for video in videos2:
TeamVideoFactory.create(team=self.team,
video=video,
added_by=self.manager_user,
project=self.project2)
self.videos_tab.open_page(project_page)
self.videos_tab.video_sort(sort_option='most subtitles')
self.videos_tab.videos_displayed()
self.assertEqual(self.videos_tab.first_video_listed(),
'lots of translations')
def test_list__video_update(self):
"""Verify video update activity.
GET /api2/partners/activity/[activity-id]/
"""
video = self.data_utils.create_video_with_subs()
TeamVideoFactory.create(team=self.open_team,
video=video,
added_by=self.user)
url_data = {
'video_url': ('http://qa.pculture.org/amara_tests/fireplace.mp4'),
'title': 'Test video created via api',
'duration': 37,
'team': self.open_team.slug
}
url_part = 'videos/'
_, response = self.data_utils.post_api_request(self.user, url_part,
url_data)
self.logger.info(response)
new_data = {
'title':
'MVC webM output sample',
'description': ('This is a sample vid converted to webM '
'720p using Miro Video Converter')
}
status, response = self.data_utils.put_api_request(
self.user, response['resource_uri'], new_data)
self.logger.info(response)
#activity_query = '?team={0}&type={1}'.format(
# self.open_team.slug, 2)
activity_query = '?team=%s&type=4' % self.open_team.slug
url_part = 'activity/%s' % activity_query
status, response = self.data_utils.api_get_request(
self.user, url_part, output_type='content')
self.logger.info(response)
self.assertEqual(200, status)
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_list__video_update(self):
"""Verify video update activity.
GET /api2/partners/activity/[activity-id]/
"""
video = self.data_utils.create_video_with_subs(self.user)
TeamVideoFactory.create(team=self.open_team,
video=video,
added_by=self.user)
url_data = {
'video_url': ('http://qa.pculture.org/amara_tests/fireplace.mp4'),
'title': 'Test video created via api',
'duration': 37,
'team': self.open_team.slug
}
url_part = 'videos/'
r = self.data_utils.make_request(self.user, 'post', url_part,
**url_data)
response = r.json
new_data = {
'title':
'MVC webM output sample',
'description': ('This is a sample vid converted to webM '
'720p using Miro Video Converter')
}
r = self.data_utils.make_request(self.user, 'put',
response['resource_uri'], **new_data)
response = r.json
#activity_query = '?team={0}&type={1}'.format(
# self.open_team.slug, 2)
activity_query = '?team=%s&type=4' % self.open_team.slug
url_part = 'activity/%s' % activity_query
r = self.data_utils.make_request(self.user, 'get', url_part)
self.assertEqual(200, r.status_code)
def setUpClass(cls):
super(TestCaseTaskFreeDashboard, cls).setUpClass()
cls.data_utils = data_helpers.DataHelpers()
cls.dashboard_tab = dashboard_tab.DashboardTab(cls)
cls.logger.info('setup: Create a team and team owner, add some videos')
cls.team_owner = UserFactory()
cls.team = TeamMemberFactory.create(user=cls.team_owner, ).team
#Add some videos with various languages required.
test_videos = [('jaws.mp4', 'fr', 'fr'),
('Birds_short.oggtheora.ogg', None, None),
('fireplace.mp4', 'en', 'en')]
for vid in test_videos:
vidurl_data = {
'url': ('http://qa.pculture.org/amara_tests/%s' % vid[0]),
'video__title': vid[0]
}
video = cls.data_utils.create_video(**vidurl_data)
if vid[1] is not None:
video_data = {
'language_code':
vid[1],
'video_language':
vid[2],
'video':
video.pk,
'draft':
open('apps/webdriver_testing/subtitle_data/'
'Timed_text.sv.dfxp'),
'is_complete':
True
}
cls.data_utils.upload_subs(video, video_data)
TeamVideoFactory(video=video,
team=cls.team,
added_by=cls.team_owner)
cls.logger.info(
'setup: Create team members Polly Glott and Mono Glot.')
cls.polly_glott = TeamContributorMemberFactory.create(
team=cls.team, user=UserFactory(username='******')).user
cls.mono_glot = TeamContributorMemberFactory.create(
team=cls.team, user=UserFactory(username='******')).user
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 test_delete_button__non_workflow_team(self):
"""Non workflow team videos have Delete Subtitle Language button.
"""
video = self.data_utils.create_video()
tv = TeamVideoFactory(team=self.basic_team,
added_by=self.owner,
video=video)
self._upload_subtitles(video, 'en', self.rev1, self.contributor)
staff = UserFactory.create(is_staff=True)
self.video_lang_pg.log_in(self.owner.username, 'password')
self.video_lang_pg.open_video_lang_page(video.video_id, 'en')
self.assertTrue(self.video_lang_pg.delete_subtitles_language_exists())
video, tv = self._add_team_video()
self._upload_subtitles(self.video, 'en', self.rev1, self.contributor)
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
def test_start__review(self):
"""Member starts review from any task in “Videos that need your help”.
"""
self.team_workflow.review_allowed = 10
self.team_workflow.save()
self.logger.info('setup: Setting task policy to all team members')
self.team.task_assign_policy = 20
self.team.video_policy = 1
self.team.save()
create_modal = dialogs.CreateLanguageSelection(self)
video = self.data_utils.create_video()
tv = TeamVideoFactory(team=self.team, added_by=self.user, video=video)
video_data = {
'language_code':
'en',
'primary_audio_language_code':
'en',
'video':
video.pk,
'draft':
open('apps/webdriver_testing/subtitle_data/'
'Timed_text.en.srt'),
'is_complete':
True,
'complete':
1
}
self.data_utils.upload_subs(video,
data=video_data,
user=dict(username=self.user.username,
password='******'))
#Login as reviewer and start the review task.
self.logger.info('Log in as user review to perform the review task.')
self.dashboard_tab.log_in(self.reviewer.username, 'password')
self.dashboard_tab.open_team_page(self.team.slug)
self.logger.info("Clicking the Review English subtitles task")
self.dashboard_tab.click_lang_task(video.title,
'Review English subtitles')
self.assertEqual('Review subtitles', self.sub_editor.dialog_title())
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 test_start__subtitles(self):
"""Member starts subtitling from dash, “Videos that need your help”.
"""
video = self.data_utils.create_video()
video.primary_audio_language_code = 'fr'
video.save()
TeamVideoFactory(team=self.team, added_by=self.user, video=video)
self.create_modal = dialogs.CreateLanguageSelection(self)
#Login user and go to team dashboard page
self.logger.info(
'Polly Glott logs in and goes to team dashboard page.')
self.dashboard_tab.log_in(self.polly_glott.username, 'password')
self.dashboard_tab.set_skiphowto()
self.dashboard_tab.open_team_page(self.team.slug)
self.dashboard_tab.click_lang_task(video.title,
'Create French subtitles')
self.create_modal.lang_selection()
self.assertEqual('Typing', self.sub_editor.dialog_title())
def test_no_langs__available_tasks(self):
"""Members with no lang prefs the list of available tasks in English.
"""
mono_glot = TeamContributorMemberFactory.create(
team=self.team, user=UserFactory()).user
video = self.data_utils.create_video()
video.primary_audio_language_code = 'fr'
video.save()
tv = TeamVideoFactory(team=self.team, added_by=self.user, video=video)
task = list(tv.task_set.incomplete_subtitle().filter(language='fr'))[0]
task.assignee = mono_glot
task.save()
#Login user and go to team dashboard page
self.dashboard_tab.log_in(mono_glot.username, 'password')
self.dashboard_tab.open_team_page(self.team.slug)
expected_lang_list = ['Create English subtitles']
langs = self.dashboard_tab.languages_needed('fireplace.mp4')
self.assertEqual(sorted(langs), sorted(expected_lang_list))
def test_members__assigned_tasks(self):
"""Members see “Videos you're working on” with assigned languages.
"""
video = self.data_utils.create_video()
video.primary_audio_language_code = 'fr'
video.save()
tv = TeamVideoFactory(team=self.team, added_by=self.user, video=video)
task = list(tv.task_set.incomplete_subtitle().filter(language='fr'))[0]
task.assignee = self.polly_glott
task.save()
#Login user and go to team dashboard page
self.dashboard_tab.log_in(self.polly_glott.username, 'password')
#Verify expected videos are displayed.
self.dashboard_tab.open_team_page(self.team.slug)
self.assertTrue(
self.dashboard_tab.dash_task_present(
task_type='Create French subtitles', title=video.title))
def test_search__metadata(self):
"""Team video search for title text after it has been updated.
"""
self.skipTest('Needs https://github.com/pculture/unisubs/issues/701')
tv = self.data_utils.create_video()
#Update the video title and description (via api)
url_part = 'videos/%s/' % tv.video_id
new_data = {
'metadata': {
'speaker-name': 'Ronaldo',
'location': 'Portugal'
}
}
self.data_utils.put_api_request(self.team_owner, url_part, new_data)
TeamVideoFactory(team=self.team, added_by=self.team_owner, video=tv)
#Update the solr index
management.call_command('update_index', interactive=False)
#Open team videos page and search for updated title text.
self.videos_tab.open_videos_tab(self.team.slug)
self.videos_tab.search('Ronaldo')
self.assertTrue(self.videos_tab.video_present(tv.title))
def _add_team_video(cls):
video = cls.data_utils.create_video()
tv = TeamVideoFactory(team=cls.team, added_by=cls.owner, video=video)
return video, tv
