def test_language_number(self):
date_maker = CreationDateMaker()
user = test_factories.create_team_member(self.team).user
video = test_factories.create_video(primary_audio_language_code='en')
test_factories.create_team_video(self.team, user, video)
self.add_subtitles(video, 'en', make_subtitle_lines(4),
created=date_maker.next_date(),
complete=True)
self.add_subtitles(video, 'fr', make_subtitle_lines(4),
created=date_maker.next_date(),
complete=True)
self.add_subtitles(video, 'de', make_subtitle_lines(4),
created=date_maker.next_date(),
complete=True)
video2 = test_factories.create_video(primary_audio_language_code='en')
test_factories.create_team_video(self.team, user, video2)
# the english version was added before the date range of the report.
# It should still bump the language number though.
self.add_subtitles(video2, 'en', make_subtitle_lines(4),
created=date_maker.date_before_start(),
complete=True)
self.add_subtitles(video2, 'fr', make_subtitle_lines(4),
created=date_maker.next_date(),
complete=True)
data = self.get_report_data(self.team,
date_maker.start_date(),
date_maker.end_date())
self.assertEquals(data['record count'], 4)
self.assertEquals(data[video.video_id]['en']['Language number'], 1)
self.assertEquals(data[video.video_id]['fr']['Language number'], 2)
self.assertEquals(data[video.video_id]['de']['Language number'], 3)
self.assertEquals(data[video2.video_id]['fr']['Language number'], 2)
def test_check_authorization_team(self):
# test check_authorization when linked to a team
team = test_factories.create_team()
tpa = test_factories.create_third_party_account(self.vurl)
tpa.teams.add(team)
self.assertEquals(check_authorization(self.video), (False, False))
test_factories.create_team_video(team, video=self.video)
self.assertEquals(check_authorization(self.video), (True, True))
def test_user_permissions_check(self):
team = test_factories.create_team(subtitle_policy=40)
test_factories.create_team_video(team=team, video=self.video)
form = self.make_form({
'primary_audio_language_code': 'en',
'subtitle_language_code': 'fr',
})
# The form should be invalid, because our user doesn't have
# permissions to subtitle the video.
self.assertEquals(form.is_valid(), False)
def test_delete_tasks(self):
# Add a review task for the last SubtitleVersion
Task(team=self.team,
team_video=self.team_video,
assignee=None,
language=self.language.language_code,
type=Task.TYPE_IDS['Review'],
new_subtitle_version=self.versions[-1]).save()
# add a completed review task for the one before that
Task(team=self.team,
team_video=self.team_video,
assignee=None,
language=self.language.language_code,
type=Task.TYPE_IDS['Review'],
approved=Task.APPROVED_IDS['Approved'],
new_subtitle_version=self.versions[-1]).save()
# add a task for another video, but with the same language
other_team_video = test_factories.create_team_video(
self.team, self.user)
Task(team=self.team,
team_video=other_team_video,
assignee=None,
language=self.language.language_code,
type=Task.TYPE_IDS['Translate']).save()
self.check_task_count(3)
# deleting the language should delete both tasks for this video, but
# not the task for the other video.
self.language.nuke_language()
self.check_task_count(1)
def test_move_video_allowed(self):
# Check that moving works when the user has permission.
video = test_factories.create_video()
old_team = test_factories.create_team(video_policy=Team.VP_MANAGER)
new_team = test_factories.create_team(video_policy=Team.VP_MANAGER)
team_video = test_factories.create_team_video(old_team, self.user,
video)
# Convenient functions for pulling models fresh from the DB.
get_video = lambda: Video.objects.get(pk=video.pk)
get_team_video = lambda: get_video().get_team_video()
# Create a member that's an admin of BOTH teams.
# This member should be able to move the video.
member = self._create_member(old_team, TeamMember.ROLE_ADMIN)
self._create_member(new_team, TeamMember.ROLE_ADMIN, member.user)
self.assertEqual(get_team_video().team.pk, old_team.pk,
"Video did not start in the correct team.")
# Move the video.
self.client.login(username=member.user.username,
password=member.user.username)
url = reverse("teams:move_video")
response = self.client.post(url, {'team_video': get_team_video().pk,
'team': new_team.pk,})
self.assertEqual(response.status_code, 302)
self.assertEqual(get_team_video().team.pk, new_team.pk,
"Video was not moved to the new team.")
self.assertEqual(get_team_video().project.team, new_team,
"Video ended up with a project for the first team")
def test_move_video_disallowed_new(self):
# Check that moving does not work when the user is blocked by the new
# team.
video = test_factories.create_video()
old_team = test_factories.create_team(video_policy=Team.VP_MANAGER)
new_team = test_factories.create_team(video_policy=Team.VP_MANAGER)
team_video = test_factories.create_team_video(old_team, self.user,
video)
# Convenient functions for pulling models fresh from the DB.
get_video = lambda: Video.objects.get(pk=video.pk)
get_team_video = lambda: get_video().get_team_video()
# Create a member that's a contributor to the new/target team.
# This member should NOT be able to move the video because they cannot
# add it to the second team.
member = self._create_member(old_team, TeamMember.ROLE_ADMIN)
self._create_member(new_team, TeamMember.ROLE_CONTRIBUTOR, member.user)
self.assertEqual(get_team_video().team.pk, old_team.pk,
"Video did not start in the correct team.")
# Try to move the video.
self.client.login(username=member.user.username,
password=member.user.username)
url = reverse("teams:move_video")
response = self.client.post(url, {'team_video': get_team_video().pk,
'team': new_team.pk,})
self.assertEqual(response.status_code, 302)
self.assertEqual(get_team_video().team.pk, old_team.pk,
"Video did not stay in the old team.")
def test_team_edit(self):
team = self._create_base_team()
self.client.login(**self.auth)
url = reverse("teams:settings_basic", kwargs={"slug": team.slug})
member = self._create_member(team, TeamMember.ROLE_ADMIN)
videos = [test_factories.create_video() for i in xrange(4)]
response = self.client.get(url)
self.failUnlessEqual(response.status_code, 200)
for video in videos:
test_factories.create_team_video(team, member.user, video)
self.assertTrue(all([v.is_public for v in videos]))
self.assertFalse(team.logo)
data = {
"name": u"New team",
"is_visible": u"0",
"description": u"testing",
"logo": open(path.join(settings.MEDIA_ROOT, "test/71600102.jpg"), "rb")
}
url = reverse("teams:settings_basic", kwargs={"slug": team.slug})
response = self.client.post(url, data)
self.failUnlessEqual(response.status_code, 302)
team = Team.objects.get(pk=team.pk)
self.assertTrue(team.logo)
self.assertEqual(team.name, u"New team")
self.assertEqual(team.description, u"testing")
self.assertFalse(team.is_visible)
self.assertTrue(all([v.is_public for v in videos]))
data = {
"name": u"New team",
"is_visible": u"1",
"description": u"testing",
}
url = reverse("teams:settings_basic", kwargs={"slug": team.slug})
response = self.client.post(url, data)
self.failUnlessEqual(response.status_code, 302)
self.assertTrue(all([v.is_public for v in videos]))
def test_no_audio_language(self):
video = test_factories.create_video(primary_audio_language_code='')
tv = test_factories.create_team_video(self.team, self.admin.user,
video)
tasks = tv.task_set.all()
self.assertEqual(tasks.count(), 1)
transcribe_task = tasks.filter(type=10, language='')
self.assertEqual(transcribe_task.count(), 1)
def test_search_by_language(self):
# make a bunch of videos that either have or don't have french
# subtitles. Make sure we test both single languages and multiple
# languages.
tv1 = test_factories.create_team_video(team=self.team)
tv2 = test_factories.create_team_video(team=self.team)
tv3 = test_factories.create_team_video(team=self.team)
tv4 = test_factories.create_team_video(team=self.team)
pipeline.add_subtitles(tv1.video, 'en', None, complete=True)
pipeline.add_subtitles(tv2.video, 'en', None, complete=True)
pipeline.add_subtitles(tv2.video, 'es', None, complete=True)
pipeline.add_subtitles(tv3.video, 'fr', None, complete=True)
pipeline.add_subtitles(tv4.video, 'en', None, complete=True)
pipeline.add_subtitles(tv4.video, 'fr', None, complete=True)
self.reindex_team_videos()
self.check_search_results(language='fr', correct=[tv3, tv4])
self.check_search_results(exclude_language='fr', correct=[tv1, tv2])
def test_missing_records(self):
date_maker = DateMaker()
user = test_factories.create_team_member(self.team).user
video = test_factories.create_video(primary_audio_language_code='en')
test_factories.create_team_video(self.team, user, video)
# For en and de, we call pipeline.add_subtitles directly, so there's
# no BillingRecord in the sytem. This simulates the languages that
# were completed before BillingRecords were around.
add_subtitles(video,
'en',
make_subtitle_lines(4),
created=date_maker.next_date(),
complete=True)
add_subtitles(video,
'de',
make_subtitle_lines(4),
created=date_maker.next_date(),
complete=True)
# pt-br has a uncompleted subtitle language. We should not list that
# language in the report
add_subtitles(video,
'pt-br',
make_subtitle_lines(4),
created=date_maker.next_date(),
complete=False)
self.add_subtitles(video,
'fr',
make_subtitle_lines(4),
created=date_maker.next_date(),
complete=True)
self.add_subtitles(video,
'es',
make_subtitle_lines(4),
created=date_maker.next_date(),
complete=True)
data = self.get_report_data(self.team, date_maker.start_date(),
date_maker.end_date())
self.assertEquals(len(data), 4)
self.assertEquals(data[video.video_id, 'en']['Language number'], 0)
self.assertEquals(data[video.video_id, 'de']['Language number'], 0)
self.assertEquals(data[video.video_id, 'fr']['Language number'], 1)
self.assertEquals(data[video.video_id, 'es']['Language number'], 2)
self.assertEquals(data[video.video_id, 'en']['Minutes'], 0)
self.assertEquals(data[video.video_id, 'de']['Minutes'], 0)
def setup_team(self):
self.team = test_factories.create_team(workflow_enabled=True)
workflow = self.team.get_workflow()
workflow.review_allowed = workflow.REVIEW_IDS['Admin must review']
workflow.approve_allowed = workflow.APPROVE_IDS['Admin must approve']
workflow.save()
self.user = test_factories.create_team_member(self.team).user
self.team_video = test_factories.create_team_video(
self.team, self.user, self.video)
def setUp(self):
TestCase.setUp(self)
self.team = test_factories.create_team()
self.project = Project.objects.create(team=self.team, name='project1')
self.team2 = test_factories.create_team()
self.project2 = Project.objects.create(team=self.team2,
name='project2')
self.video = test_factories.create_video()
self.team_video = test_factories.create_team_video(self.team,
video=self.video)
def test_search(self):
video = test_factories.create_video(primary_audio_language_code='en',
title='MyTitle')
tv = test_factories.create_team_video(self.team, self.admin.user,
video)
self.assertEqual(tv.task_set.count(), 1)
self.check_task_list(tv.task_set.all(), q='MyTitle')
self.check_task_list(tv.task_set.all(), q='mytitle')
self.check_task_list(tv.task_set.all(), q='my')
self.check_task_list([], q='OtherTitle')
def test_search_by_metadata(self):
video = test_factories.create_video(primary_audio_language_code='en',
title='MyTitle')
video.update_metadata({'speaker-name': 'Person'})
tv = test_factories.create_team_video(self.team, self.admin.user,
video)
self.assertEqual(tv.task_set.count(), 1)
self.check_task_list(tv.task_set.all(), q='Person')
self.check_task_list(tv.task_set.all(), q='person')
self.check_task_list(tv.task_set.all(), q='pers')
def test_team_permission(self):
team = test_factories.create_team(slug="private-team",
name="Private Team",
is_visible=False)
TeamMember.objects.create_first_member(team, self.user)
video = test_factories.create_video()
test_factories.create_team_video(team, self.user, video)
url = reverse("videos:video", kwargs={"video_id": video.video_id})
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 404)
self.client.login(**self.auth)
response = self.client.get(url, follow=True)
self.assertEquals(response.status_code, 200)
self.client.logout()
def setUp(self, mock_now):
self.date_maker = DateMaker()
mock_now.side_effect = self.date_maker.next_date
self.team = test_factories.create_team(workflow_enabled=True)
test_factories.create_workflow(
self.team,
review_allowed=0, # no review
approve_allowed=20, # admin must approve
)
self.admin = test_factories.create_team_member(team=self.team,
role=ROLE_ADMIN).user
self.video = test_factories.create_team_video(self.team).video
def setUp(self):
self.team = test_factories.create_team(workflow_enabled=True)
self.workflow = test_factories.create_workflow(
self.team,
review_allowed=DONT_REQUIRE_REVIEW,
approve_allowed=DONT_REQUIRE_APPROVAL)
self.admin = test_factories.create_team_member(
self.team, role=TeamMember.ROLE_ADMIN)
self.team_video = test_factories.create_team_video(
self.team, self.admin.user)
self.client = Client()
self.login(self.admin.user)
def setUp(self, mock_delete_subtitles, mock_update_subtitles, mock_now):
self.now = datetime.datetime(2013, 1, 1)
mock_now.side_effect = self.make_now
self.mock_update_subtitles = mock_update_subtitles
self.mock_delete_subtitles = mock_delete_subtitles
self.video = create_kaltura_video('video')
self.video_url = self.video.get_primary_videourl_obj()
team_video = test_factories.create_team_video(video=self.video)
self.team = team_video.team
self.account = KalturaAccount.objects.create(team=self.team,
partner_id=1234,
secret='abcd')
pipeline.add_subtitles(self.video, 'en', None)
self.reset_history()
def test_minutes(self):
date_maker = DateMaker()
user = test_factories.create_team_member(self.team).user
video = test_factories.create_video(primary_audio_language_code='en')
test_factories.create_team_video(self.team, user, video)
self.add_subtitles(video,
'en',
make_subtitle_lines(100, 100),
created=date_maker.next_date(),
complete=True)
self.add_subtitles(video,
'fr',
make_subtitle_lines(100, 80),
created=date_maker.next_date(),
complete=True)
data = self.get_report_data(self.team, date_maker.start_date(),
date_maker.end_date())
self.assertEquals(len(data), 2)
# For english the duration is 1:40, for french it's 1:20. We should
# always round up, so both should count as 2 minutes
self.assertEquals(data[video.video_id, 'en']['Minutes'], 2)
self.assertEquals(data[video.video_id, 'fr']['Minutes'], 2)
def setUp(self, mock_delete_subtitles, mock_update_subtitles,
mock_update_all_subtitles):
self.mock_delete_subtitles = mock_delete_subtitles
self.mock_update_subtitles = mock_update_subtitles
self.mock_update_all_subtitles = mock_update_all_subtitles
self.video = create_kaltura_video('video')
self.video_url = self.video.get_primary_videourl_obj()
team_video = test_factories.create_team_video(video=self.video)
self.team = team_video.team
self.account = KalturaAccount.objects.create(team=self.team,
partner_id=1234,
secret='abcd')
pipeline.add_subtitles(self.video, 'en', None)
self.mock_update_all_subtitles.reset_mock()
self.mock_update_subtitles.reset_mock()
self.mock_delete_subtitles.reset_mock()
def setUp(self):
self.team = test_factories.create_team(workflow_enabled=True)
self.workflow = test_factories.create_workflow(self.team)
self.user = test_factories.create_user(is_staff=True)
self.member = test_factories.create_team_member(self.team,
self.user,
role=ROLE_ADMIN)
self.video = test_factories.create_video()
self.team_video = test_factories.create_team_video(
self.team, self.user, self.video)
self.non_team_video = test_factories.create_video()
# create a bunch of versions
self.versions = [
pipeline.add_subtitles(self.video, 'en', None) for i in xrange(5)
]
self.language = self.video.get_primary_audio_subtitle_language()
def test_rules(self):
team_video = test_factories.create_team_video()
video = team_video.video
username = video.user.username
def check_sync_rule(should_sync, **rule_kwargs):
YoutubeSyncRule.objects.all().delete()
rule = YoutubeSyncRule.objects.create(**rule_kwargs)
self.assertEquals(rule.should_sync(video), should_sync)
check_sync_rule(False) # blank rule
check_sync_rule(True, team=team_video.team.slug)
check_sync_rule(True, user=username)
check_sync_rule(True, video=video.video_id)
check_sync_rule(True, team='*')
# Videos can have the user field set to None
video.user = None
video.save()
check_sync_rule(False, user=username)
def setUp(self):
self.video = test_factories.create_video()
self.team = test_factories.create_team()
self.member = test_factories.create_team_member(self.team)
self.team_video = test_factories.create_team_video(
self.team, self.member.user, self.video)
def test_tasks_not_called_for_non_team_videos(self):
video = test_factories.create_video()
test_factories.create_team_video(team=self.team, video=video)
self.check_tasks_not_called(video)
def test_tasks_not_called_if_no_account(self):
# for non-team videos, we shouldn't schedule a task
video = create_kaltura_video('video2')
other_team = test_factories.create_team()
test_factories.create_team_video(other_team, video=video)
self.check_tasks_not_called(video)
def setup_videos(self):
# make a bunch of languages that have moved through the review process
self.subtitled_languages = collections.defaultdict(list)
self.reviewed_languages = collections.defaultdict(list)
self.notes = {}
self.approved_languages = []
self.approval_dates = {}
self.review_dates = {}
self.subtitle_dates = {}
self.translations = set()
v1 = test_factories.create_team_video(self.team).video
v2 = test_factories.create_team_video(self.team).video
v3 = test_factories.create_team_video(self.team).video
languages = [
(v1, 'en'),
(v1, 'fr'),
(v1, 'de'),
(v1, 'pt-br'),
(v2, 'en'),
(v2, 'es'),
(v2, 'fr'),
(v2, 'de'),
(v2, 'pt-br'),
(v3, 'en'),
(v3, 'de'),
]
self.videos = {
v1.video_id: v1,
v2.video_id: v2,
v3.video_id: v3,
}
notes_iter = itertools.cycle(['Great', 'Bad', 'Okay', ''])
for i, (video, language_code) in enumerate(languages):
video_id = video.video_id
subtitler = self.subtitler_iter.next()
reviewer = self.reviewer_iter.next()
note = notes_iter.next()
if i % 3 == 0:
task_type = 'Translate'
self.translations.add((video_id, language_code))
else:
task_type = 'Subtitle'
review_task = test_factories.make_review_task(
video.get_team_video(),
language_code,
subtitler,
task_type,
sub_data=make_subtitle_lines(10, 90))
self.subtitle_dates[video_id, language_code] = \
self.date_maker.current_date
review_task.body = note
approve_task = review_task.complete_approved(reviewer)
self.review_dates[video_id, language_code] = \
self.date_maker.current_date
self.assertEquals(approve_task.type, Task.TYPE_IDS['Approve'])
self.notes[video_id, language_code, 'Review'] = note
if i < 6:
# for some of those videos, approve them
approve_task.complete_approved(self.admin)
self.add_approved_language(video, language_code, subtitler,
reviewer)
if 6 <= i < 8:
# for some of those videos, send them back to review, then
# review again and approve the final result
# for some of those videos, approve them
review_task2 = approve_task.complete_rejected(self.admin)
note = notes_iter.next()
review_task2.body = note
self.notes[video_id, language_code, 'Review'] = note
approve_task2 = review_task2.complete_approved(reviewer)
self.review_dates[video_id, language_code] = \
self.date_maker.current_date
approve_task2.complete_approved(self.admin)
self.add_approved_language(video, language_code, subtitler,
reviewer)
def create_team_video():
return test_factories.create_team_video(team, owner.user)
def setup_videos(self):
self.project_video = test_factories.create_team_video(
self.team, self.owner_account, project=self.test_project)
self.nonproject_video = test_factories.create_team_video(
self.team, self.owner_account)
