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_gauge_videos_long(self):
video1 = test_factories.create_video()
video2 = test_factories.create_video()
pipeline.add_subtitles(video1, 'de', [
(100, 200, "foo", {
'new_paragraph': True
}),
(300, 400, "bar", {
'new_paragraph': True
}),
])
pipeline.add_subtitles(video2, 'en', [
(100, 200, "foo", {
'new_paragraph': True
}),
(300, 400, "bar", {
'new_paragraph': True
}),
])
pipeline.add_subtitles(video2, 'en', [
(100, 200, "foo", {
'new_paragraph': True
}),
(300, 400, "bar", {
'new_paragraph': True
}),
(500, 600, "baz", {
'new_paragraph': True
}),
])
gauge_videos_long()
self.assertEquals(set(self.gauges.keys()), set([
'videos.Subtitle',
]))
self.gauges['videos.Subtitle'].report.assert_called_once_with(5)
def make_three_objects(self):
v1 = test_factories.create_video()
v2 = test_factories.create_video()
return [
pipeline.add_subtitles(v1, 'en', None).subtitle_language,
pipeline.add_subtitles(v1, 'fr', None).subtitle_language,
pipeline.add_subtitles(v2, 'en', None).subtitle_language,
]
def test_gauge_videos(self):
videos = [test_factories.create_video() for i in range(10)]
# video #1 has 1 language with 1 version
pipeline.add_subtitles(videos[0], 'en', None)
# video #2 has 2 languages with 1 version
pipeline.add_subtitles(videos[1], 'en', None)
pipeline.add_subtitles(videos[1], 'fr', None)
# video #3 has 2 languages with 2 versions
pipeline.add_subtitles(videos[2], 'de', None)
pipeline.add_subtitles(videos[2], 'de', None)
pipeline.add_subtitles(videos[2], 'pt-br', None)
pipeline.add_subtitles(videos[2], 'pt-br', None)
gauge_videos()
self.assertEquals(
set(self.gauges.keys()),
set([
'videos.Video',
'videos.Video-captioned',
'videos.SubtitleVersion',
'videos.SubtitleLanguage',
]))
gauges = self.gauges
gauges['videos.Video'].report.assert_called_once_with(10)
gauges['videos.Video-captioned'].report.assert_called_once_with(3)
gauges['videos.SubtitleVersion'].report.assert_called_once_with(7)
gauges['videos.SubtitleLanguage'].report.assert_called_once_with(5)
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_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 create_kaltura_video(name):
# generate something that looks like a kaltura id
entry_id = '1_' + hashlib.md5(name).hexdigest()[:8]
url = ('http://cdnbakmi.kaltura.com'
'/p/1492321/sp/149232100/serveFlavor/entryId/'
'%s/flavorId/1_dqgopb2z/name/%s.mp4') % (entry_id, name)
return test_factories.create_video(url=url, video_type='K')
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_noop_for_non_team_feed(self):
team = test_factories.create_team()
user = test_factories.create_user()
videos = [test_factories.create_video() for i in xrange(5)]
feed = mock.Mock(team=None, user=user)
feed_imported.send(sender=feed, new_videos=videos)
for video in videos:
self.assertEquals(video.get_team_video(), None)
def setUp(self):
TestCase.setUp(self)
self.video = test_factories.create_video()
self.video.update_metadata({
'location': 'Place',
})
pipeline.add_subtitles(self.video, 'fr', None, metadata={
'location': 'Place-fr',
})
def test_video_language_title_fallback(self):
# if a language doesn't have a title, then we fall back to the video
# title (which is the english title, since that's the primary audoio
video = test_factories.create_video(primary_audio_language_code='en',
title='Video Title')
en_version = pipeline.add_subtitles(video, 'en', None)
en = en_version.subtitle_language
self.assertEquals(views.language_page_title(en),
'Video Title with subtitles | Amara')
def test_migrate_updates_view_count(self):
video = test_factories.create_video()
video2 = test_factories.create_video()
self.add_hit(video, datetime(2013, 1, 1, 0))
self.add_hit(video, datetime(2013, 1, 1, 1))
self.add_hit(video, datetime(2013, 1, 1, 2))
self.add_hit(video2, datetime(2013, 1, 1, 3))
self.add_hit(video2, datetime(2013, 1, 1, 4))
self.migrate(datetime(2013, 1, 2, 0, 5))
self.assertEquals(Video.objects.get(id=video.id).view_count, 3)
self.assertEquals(Video.objects.get(id=video2.id).view_count, 2)
self.add_hit(video, datetime(2013, 1, 2, 0))
self.add_hit(video, datetime(2013, 1, 2, 1))
self.add_hit(video, datetime(2013, 1, 2, 2))
self.add_hit(video, datetime(2013, 1, 2, 3))
self.migrate(datetime(2013, 1, 3, 0, 5))
self.assertEquals(Video.objects.get(id=video.id).view_count, 7)
self.assertEquals(Video.objects.get(id=video2.id).view_count, 2)
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_video_language_title(self):
video = test_factories.create_video(primary_audio_language_code='en',
title='Video Title')
en_version = pipeline.add_subtitles(video,
'en',
None,
title="English Title")
en = en_version.subtitle_language
self.assertEquals(views.language_page_title(en),
'English Title with subtitles | Amara')
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_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 setUp(self):
TestCase.setUp(self)
self.partner_id = 1234
self.secret = 'Secret'
self.account = KalturaAccount.objects.create(
team=test_factories.create_team(),
partner_id=self.partner_id,
secret=self.secret)
self.entry_id = 'EntryId'
url = ('http://cdnbakmi.kaltura.com'
'/p/1492321/sp/149232100/serveFlavor/entryId/'
'%s/flavorId/1_dqgopb2z/name/video.mp4') % self.entry_id
self.video = test_factories.create_video(url=url, video_type='K')
self.video_url = self.video.get_primary_videourl_obj()
self.version = pipeline.add_subtitles(self.video, 'en',
[(100, 200, "sub 1")])
self.language = self.version.subtitle_language
def test_video_language_title_translation(self):
# for translated languages, we display the title in the same way. In
# the past we displayed it differently, this test is still useful
video = test_factories.create_video(primary_audio_language_code='en',
title='Video Title')
en_version = pipeline.add_subtitles(video,
'en',
None,
title="English Title")
fr_version = pipeline.add_subtitles(video,
'fr',
None,
title="French Title",
parents=[en_version])
fr = fr_version.subtitle_language
self.assertEquals(views.language_page_title(fr),
'French Title with subtitles | Amara')
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 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 test_create_team_videos_for_team_feed(self):
api_teamvideo_new_handler = mock.Mock()
api_teamvideo_new.connect(api_teamvideo_new_handler, weak=False)
self.addCleanup(api_teamvideo_new.disconnect,
api_teamvideo_new_handler)
team = test_factories.create_team()
user = test_factories.create_team_member(team).user
videos = [test_factories.create_video() for i in xrange(5)]
feed = mock.Mock(team=team, user=user)
feed_imported.send(sender=feed, new_videos=videos)
for video in videos:
self.assertNotEquals(video.get_team_video(), None)
self.assertEquals(video.get_team_video().team, team)
correct_api_calls = [
mock.call(signal=api_teamvideo_new, sender=video.get_team_video())
for video in videos
]
api_teamvideo_new_handler.assert_has_calls(correct_api_calls,
any_order=True)
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):
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 make_three_objects(self):
return [test_factories.create_video() for i in range(3)]
def setUp(self):
TestCase.setUp(self)
self.video = test_factories.create_video()
def setUp(self):
self.video = test_factories.create_video()
self.user_0 = test_factories.create_user()
def setUp(self, mock_get_user_languages_from_request):
self.video = test_factories.create_video()
self.user = test_factories.create_user()
self.mock_get_user_languages_from_request = \
mock_get_user_languages_from_request
