def test_team(self):
team = TeamFactory(slug='team', admin=self.user)
video1 = VideoFactory(video_id='video1',
primary_audio_language_code='fr',
team=team)
video2 = VideoFactory(video_id='video2', team=team)
other_video = VideoFactory()
v1 = pipeline.add_subtitles(video1,
'en',
SubtitleSetFactory(),
author=self.user)
self.clear_records()
record1 = ActivityRecord.objects.create_for_video_added(video1)
record2 = ActivityRecord.objects.create_for_video_added(video2)
record3 = ActivityRecord.objects.create_for_subtitle_version(v1)
# this record should never be listed in the endpoint
ActivityRecord.objects.create_for_video_added(other_video)
url = reverse('api:team-activity', args=(team.slug, ))
self.check_list(url, record3, record2, record1)
self.check_list(url + '?video=video1', record3, record1)
self.check_list(url + '?user=test-user', record3)
self.check_list(url + '?user=id${}'.format(self.user.secure_id()),
record3)
self.check_list(url + '?video_language=fr', record3, record1)
self.check_list(url + '?type=video-added', record2, record1)
self.check_list(url + '?language=en', record3)
self.check_list(
url + '?before=' + format_datetime_field(record2.created), record1)
self.check_list(
url + '?after=' + format_datetime_field(record2.created), record3,
record2)
def test_video(self):
video = VideoFactory(user=self.user)
other_video = VideoFactory()
v1 = pipeline.add_subtitles(video, 'en', SubtitleSetFactory())
v2 = pipeline.add_subtitles(video,
'fr',
SubtitleSetFactory(),
author=self.user)
self.clear_records()
record1 = ActivityRecord.objects.create_for_video_added(video)
record2 = ActivityRecord.objects.create_for_subtitle_version(v1)
record3 = ActivityRecord.objects.create_for_subtitle_version(v2)
# this record should never be listed in the endpoint
ActivityRecord.objects.create_for_video_added(other_video)
url = reverse('api:video-activity', args=(video.video_id, ))
self.check_list(url, record3, record2, record1)
self.check_list(url + '?type=video-added', record1)
self.check_list(url + '?user=test-user', record3, record1)
self.check_list(url + '?language=en', record2)
self.check_list(
url + '?before=' + format_datetime_field(record2.created), record1)
self.check_list(
url + '?after=' + format_datetime_field(record2.created), record3,
record2)
self.check_list(url + '?user=test-user&language=fr', record3)
def check_application_data(self, data, application):
assert_equal(data['user'], application.user.username)
assert_equal(data['note'], application.note)
assert_equal(data['status'], application.get_status_display())
assert_equal(data['id'], application.id)
assert_equal(data['created'],
format_datetime_field(application.created))
if application.modified:
assert_equal(data['modified'],
format_datetime_field(application.modified))
else:
assert_equal(data['modified'], None)
assert_equal(data['resource_uri'], self.detail_url(application))
def check_project_data(self, data, project):
assert_equal(data['name'], project.name)
assert_equal(data['slug'], project.slug)
assert_equal(data['description'], project.description)
assert_equal(data['guidelines'], project.guidelines)
assert_equal(data['created'], format_datetime_field(project.created))
assert_equal(data['modified'],
format_datetime_field(project.modified))
assert_equal(data['workflow_enabled'], project.workflow_enabled)
assert_equal(data['resource_uri'],
reverse('api:projects-detail', kwargs={
'team_slug': self.team.slug,
'slug': project.slug,
}, request=APIRequestFactory().get('/')))
def check_data(self, activity_data, record):
assert_equal(activity_data['type'], record.type)
assert_equal(activity_data['date'],
format_datetime_field(record.created))
if record.video:
assert_equal(activity_data['video'], record.video.video_id)
assert_equal(
activity_data['video_uri'],
reverse('api:video-detail',
kwargs={
'video_id': record.video.video_id,
},
request=APIRequestFactory().get('/')))
else:
assert_equal(activity_data['video'], None)
assert_equal(activity_data['video_uri'], None)
if record.language_code:
assert_equal(activity_data['language'], record.language_code)
assert_equal(
activity_data['language_uri'],
reverse('api:subtitle-language-detail',
kwargs={
'video_id': record.video.video_id,
'language_code': record.language_code,
},
request=APIRequestFactory().get('/')))
else:
assert_equal(activity_data['language'], None)
assert_equal(activity_data['language_uri'], None)
assert_equal(activity_data['user'], user_field_data(record.user))
def test_fields(self):
serializer_data = self.get_serializer_data()
assert_equal(serializer_data['id'], self.language.id)
assert_equal(serializer_data['created'],
format_datetime_field(self.language.created))
assert_equal(serializer_data['is_original'], True)
assert_equal(serializer_data['is_primary_audio_language'], True)
assert_equal(serializer_data['is_rtl'], self.language.is_rtl())
assert_equal(serializer_data['published'],
self.language.has_public_version())
assert_equal(serializer_data['language_code'],
self.language.language_code)
assert_equal(serializer_data['name'],
self.language.get_language_code_display())
assert_equal(serializer_data['title'], self.language.get_title())
assert_equal(serializer_data['description'],
self.language.get_description())
assert_equal(serializer_data['metadata'], self.language.get_metadata())
assert_equal(serializer_data['subtitle_count'],
self.language.get_subtitle_count())
assert_equal(serializer_data['subtitles_complete'],
self.language.subtitles_complete)
assert_equal(serializer_data['is_translation'],
compat.subtitlelanguage_is_translation(self.language))
assert_equal(
serializer_data['original_language_code'],
compat.subtitlelanguage_original_language_code(self.language))
assert_equal(
serializer_data['resource_uri'],
reverse('api:subtitle-language-detail',
kwargs={
'video_id': self.video.video_id,
'language_code': self.language.language_code,
},
request=APIRequestFactory().get("/")))
def correct_data(self, video_url):
return {
'created': format_datetime_field(video_url.created),
'url': video_url.url,
'primary': video_url.primary,
'original': video_url.original,
'id': video_url.id,
'resource_uri': self.detail_url(video_url),
}
def test_video(self):
video = VideoFactory(user=self.user)
other_video = VideoFactory()
v1 = pipeline.add_subtitles(video, 'en', SubtitleSetFactory())
v2 = pipeline.add_subtitles(video,
'fr',
SubtitleSetFactory(),
author=self.user)
self.clear_records()
record1 = ActivityRecord.objects.create_for_video_added(video)
record2 = ActivityRecord.objects.create_for_subtitle_version(v1)
record3 = ActivityRecord.objects.create_for_subtitle_version(v2)
# this record should never be listed in the endpoint
ActivityRecord.objects.create_for_video_added(other_video)
url = reverse('api:video-activity', args=(video.video_id, ))
self.check_list(url, record3, record2, record1)
self.check_list(url + '?type=video-added', record1)
self.check_list(url + '?user=test-user', record3, record1)
self.check_list(url + '?language=en', record2)
# We should accept filtering with or without time zone, date or datetime
self.check_list(
url + '?before=' + format_datetime_field(record2.created), record1)
self.check_list(url + '?before=' + record2.created.isoformat(),
record1)
self.check_list(
url + '?after=' + format_datetime_field(record2.created), record3,
record2)
self.check_list(url + '?after=' + record2.created.isoformat(), record3,
record2)
self.check_list(url + '?before=' +
format_datetime_field_as_date(record2.created))
self.check_list(
url + '?after=' + format_datetime_field_as_date(record3.created),
record3, record2, record1)
tomorrow = record1.created + timedelta(days=1)
self.check_list(
url + '?before=' + format_datetime_field_as_date(tomorrow),
record3, record2, record1)
yesterday = record1.created - timedelta(days=1)
self.check_list(
url + '?after=' + format_datetime_field_as_date(yesterday),
record3, record2, record1)
self.check_list(url + '?user=test-user&language=fr', record3)
def test_simple_fields(self):
data = self.get_serialized_data()
assert_equal(data['id'], self.video.video_id)
assert_equal(data['title'], self.video.title)
assert_equal(data['description'], self.video.description)
assert_equal(data['duration'], self.video.duration)
assert_equal(data['created'],
format_datetime_field(self.video.created))
assert_equal(data['thumbnail'], self.thumbnail_url)
assert_equal(
data['resource_uri'],
'http://testserver/api/videos/{0}/'.format(self.video.video_id))
def check_activity_data(self, activity_data, record):
assert_equal(activity_data['id'], record.id)
assert_equal(activity_data['type'], record.type_code)
assert_equal(activity_data['type_name'], record.type)
assert_equal(activity_data['created'],
format_datetime_field(record.created))
if record.type == 'video-url-edited':
assert_equal(activity_data['new_video_title'],
record.get_related_obj().new_title)
else:
assert_equal(activity_data['new_video_title'], None)
if record.type == 'comment-added':
assert_equal(activity_data['comment'],
record.get_related_obj().content)
else:
assert_equal(activity_data['comment'], None)
assert_equal(
activity_data['resource_uri'],
reverse('api:activity-detail',
kwargs={'id': record.id},
request=APIRequestFactory().get('/')))
if record.video:
assert_equal(activity_data['video'], record.video.video_id)
assert_equal(
activity_data['video_uri'],
reverse('api:video-detail',
kwargs={
'video_id': record.video.video_id,
},
request=APIRequestFactory().get('/')))
else:
assert_equal(activity_data['video'], None)
assert_equal(activity_data['video_uri'], None)
if record.language_code:
assert_equal(activity_data['language'], record.language_code)
assert_equal(
activity_data['language_url'],
reverse('api:subtitle-language-detail',
kwargs={
'video_id': record.video.video_id,
'language_code': record.language_code,
},
request=APIRequestFactory().get('/')))
else:
assert_equal(activity_data['language'], None)
assert_equal(activity_data['language_url'], None)
if record.user:
assert_equal(activity_data['user'], record.user.username)
else:
assert_equal(activity_data['user'], None)
def check_activity_data(self, activity_data, activity):
assert_equal(activity_data['type'], activity.action_type)
assert_equal(activity_data['created'],
format_datetime_field(activity.created))
assert_equal(activity_data['new_video_title'],
activity.new_video_title)
assert_equal(activity_data['id'], activity.id)
if activity.comment:
assert_equal(activity_data['comment'], activity.comment.content)
else:
assert_equal(activity_data['comment'], None)
assert_equal(
activity_data['resource_uri'],
reverse('api:activity-detail',
kwargs={'id': activity.id},
request=APIRequestFactory().get('/')))
if activity.video:
assert_equal(activity_data['video'], activity.video.video_id)
assert_equal(
activity_data['video_uri'],
reverse('api:video-detail',
kwargs={
'video_id': activity.video.video_id,
},
request=APIRequestFactory().get('/')))
else:
assert_equal(activity_data['video'], None)
assert_equal(activity_data['video_uri'], None)
if activity.new_language:
assert_equal(activity_data['language'],
activity.new_language.language_code)
assert_equal(
activity_data['language_url'],
reverse('api:subtitle-language-detail',
kwargs={
'video_id': activity.new_language.video.video_id,
'language_code':
activity.new_language.language_code,
},
request=APIRequestFactory().get('/')))
else:
assert_equal(activity_data['language'], None)
assert_equal(activity_data['language_url'], None)
if activity.user:
assert_equal(activity_data['user'], activity.user.username)
else:
assert_equal(activity_data['user'], None)
def test_list(self):
note = SubtitleNote.objects.create(user=self.user,
video=self.video,
language_code='en',
body='test note')
# also create a note from another language. This one shouldn't be
# included in the reply
SubtitleNote.objects.create(user=self.user,
video=self.video,
language_code='fr',
body='wrong test note')
response = self.client.get(self.api_path)
assert_equal(response.status_code, 200)
data = json.loads(response.content)
assert_equal(data, [{
'user': self.user.username,
'body': 'test note',
'created': format_datetime_field(note.created),
}])
def check_task_data(self, data, task):
assert_equal(data['video_id'], task.team_video.video.video_id)
assert_equal(data['language'], task.language)
assert_equal(data['id'], task.id)
assert_equal(data['type'], task.get_type_display())
if task.assignee:
assert_equal(data['assignee'], task.assignee.username)
else:
assert_equal(data['assignee'], None)
assert_equal(data['priority'], task.priority)
if task.completed:
assert_equal(data['completed'],
format_datetime_field(task.completed))
else:
assert_equal(data['completed'], None)
assert_equal(data['approved'], task.get_approved_display())
assert_equal(data['resource_uri'],
reverse('api:tasks-detail', kwargs={
'team_slug': self.team.slug,
'id': task.id,
}, request=APIRequestFactory().get('/')))
