def test_video_languages_count(self): # TODO: Merge this into the metadata tests file? video = get_video() # Start with no languages. self.assertEqual(video.languages_count, 0) self.assertEqual( video.newsubtitlelanguage_set.having_nonempty_tip().count(), 0) # Create one. sl_en = make_subtitle_language(video, 'en') make_subtitle_version(sl_en, [(100, 200, "foo")]) # The query should immediately show it. self.assertEqual( video.newsubtitlelanguage_set.having_nonempty_tip().count(), 1) # But the model object will not. self.assertEqual(video.languages_count, 0) # Even if we refresh it, the model still doesn't show it. video = Video.objects.get(pk=video.pk) self.assertEqual(video.languages_count, 0) # Until we run the proper tasks. video_changed_tasks.delay(video.pk) test_utils.video_changed_tasks.run_original() # But we still need to refresh it to see the change. self.assertEqual(video.languages_count, 0) video = Video.objects.get(pk=video.pk) self.assertEqual(video.languages_count, 1)
def test_subtitle_language_save(self): def _refresh(video): video_changed_tasks.delay(video.pk) test_utils.video_changed_tasks.run_original() return Video.objects.get(pk=video.pk) # Start out with a video with one language. # By default languages are not complete, so the video should not be # complete either. video = get_video() sl_en = make_subtitle_language(video, 'en') self.assertIsNone(video.complete_date) self.assertEqual(video.newsubtitlelanguage_set.count(), 1) # Marking the language as complete doesn't complete the video on its own # -- we need at least one version! sl_en.subtitles_complete = True sl_en.save() video = _refresh(video) self.assertIsNone(video.complete_date) # But an unsynced version can't be complete either! # TODO: uncomment once babelsubs supports unsynced subs... # make_subtitle_version(sl_en, [(100, None, "foo")]) # video = _refresh(video) # self.assertIsNone(video.complete_date) # A synced version (plus the previously set flag on the language) should # result in a completed video. make_subtitle_version(sl_en, [(100, 200, "foo")]) video = _refresh(video) self.assertIsNotNone(video.complete_date) # Unmarking the language as complete should uncomplete the video. sl_en.subtitles_complete = False sl_en.save() video = _refresh(video) self.assertIsNone(video.complete_date) # Any completed language is enough to complete the video. sl_ru = make_subtitle_language(video, 'ru') make_subtitle_version(sl_ru, [(100, 200, "bar")]) sl_ru.subtitles_complete = True sl_ru.save() video = _refresh(video) self.assertIsNotNone(video.complete_date)
def test_create_edit_subs(self): video = get_video(1) sl_en = make_subtitle_language(video, 'en') # Start off with zero followers. self._assertFollowers(video, []) self._assertFollowers(sl_en, []) # Transcriber/translator should follow only the language, not the video. en_author = get_user(1) make_subtitle_version(sl_en, author=en_author) self._assertFollowers(video, []) self._assertFollowers(sl_en, [en_author]) # Create a "translation". sl_ru = make_subtitle_language(video, 'ru') self.assertEqual(sl_ru.followers.count(), 0) ru_author = get_user(2) make_subtitle_version(sl_ru, author=ru_author, parents=[('en', 1)]) # Translation editors should follow only the language, not the video. self.assertEqual(sl_ru.get_translation_source_language_code(), 'en') self._assertFollowers(video, []) self._assertFollowers(sl_en, [en_author]) self._assertFollowers(sl_ru, [ru_author]) # Editors should also follow only the language, not the video. editor = get_user(3) make_subtitle_version(sl_en, author=editor) self._assertFollowers(video, []) self._assertFollowers(sl_en, [en_author, editor]) self._assertFollowers(sl_ru, [ru_author]) make_subtitle_version(sl_ru, author=editor) self._assertFollowers(video, []) self._assertFollowers(sl_en, [en_author, editor]) self._assertFollowers(sl_ru, [ru_author, editor])
def test_video_title(self): video = get_video(url='http://www.youtube.com/watch?v=pQ9qX8lcaBQ') def _assert_title(correct_title): self.assertEquals(refresh(video).title, correct_title) # Test title before any subtitles are added. _assert_title(test_utils.test_video_info.title) # Make a subtitle language in the primary language. video.primary_audio_language_code = 'en' video.save() sl_en = make_subtitle_language(video, 'en') # Just adding languages shouldn't affect the title. _assert_title(test_utils.test_video_info.title) # Add subtitles with a custom title. The title should be updated to # reflect this. make_subtitle_version(sl_en, [], title="New Title") _assert_title("New Title") # New versions should continue update the title properly. make_subtitle_version(sl_en, [], title="New Title 2") _assert_title("New Title 2") # Versions in a non-primary-audio-language should not affect the video # title. sl_ru = make_subtitle_language(video, 'ru') make_subtitle_version(sl_ru, [], title="New Title 3") _assert_title("New Title 2") # Rollbacks (of the primary audio language) should affect the title just # like a new version. make_rollback_to(sl_en, 1) _assert_title("New Title")
def test_dfxp_serializer(self): video = get_video() sl_en = make_subtitle_language(video, 'en') video.primary_audio_language_code = 'en' video.save() make_subtitle_version(sl_en, [(100, 200, 'Here we go!')], title='title') sl_en = reload_obj(sl_en) content = self._download_subs(sl_en, 'dfxp') serialized = DFXPParser(content) subtitle_set = serialized.to_internal() self.assertEqual(len(subtitle_set), 1) start, end, content, meta = list(subtitle_set)[0] self.assertEqual(start, 100) self.assertEqual(end, 200) self.assertEqual(content, 'Here we go!')
def test_upload_respects_lock(self): user1 = get_user(1) user2 = get_user(2) video = get_video() sl_en = make_subtitle_language(video, 'en') # Lock the language for user 1. sl_en.writelock(user1, 'test-browser-id') self.assertTrue(sl_en.is_writelocked) # Now try to upload subtitles as user 2. self._login(user2) self._upload(video, 'en', 'en', None, True, 'test.srt') # The subtitles should not have been created. # # We can't really tests the response here because the upload_subtitles # view is terrible and always returns a 200 with a horrible mix of HTML # and JSON as a response. So instead we'll just make sure that the # subtitles were not actually created. self.assertFalse(sl_en.subtitleversion_set.full().exists()) # User 1 has the writelock, so uploading subtitles should work for them. self._login(user1) self._upload(video, 'en', 'en', None, True, 'test.srt') self.assertEqual(sl_en.subtitleversion_set.full().count(), 1) # User 1 still has the writelock, so user 2 still can't upload. self._login(user2) self._upload(video, 'en', 'en', None, True, 'test.srt') self.assertEqual(sl_en.subtitleversion_set.full().count(), 1) # Release the writelock. sl_en.release_writelock() # Now user 2 can finally upload their subtitles. self._login(user2) self._upload(video, 'en', 'en', None, True, 'test.srt') self.assertEqual(sl_en.subtitleversion_set.full().count(), 2)
def test_language_url_for_empty_lang(self): v = get_video(1) sl = make_subtitle_language(v, 'en') self.assertIsNotNone(language_url(None, sl))