def test_upload_and_rollbacks(self):
video = get_video()
self._assertCounts(video, {})
self._upload(video, 'en', 'en', None, True, 'test.srt')
self._upload(video, 'en', 'en', None, True, 'test_fewer_subs.srt')
self._upload(video, 'fr', 'en', 'en', True, 'test_fewer_subs.srt')
self._assertCounts(video, {'en': 2, 'fr': 1})
# We now have:
#
# en fr
# 1
# /
# /
# 2
# |
# 1
# Let's sanity check that we can still upload to English now that it has
# a dependent language (French).
self._upload(video, 'en', 'en', None, True, 'test_fewer_subs.srt')
self._assertCounts(video, {'en': 3, 'fr': 1})
# The translation should now be forked.
self.assertTrue(video.subtitle_language('fr').is_forked)
# Now let's roll English back to v1.
pipeline.rollback_to(video, 'en', 1)
self._assertCounts(video, {'en': 4, 'fr': 1})
# And try uploading something on top of the rollback.
self._upload(video, 'en', 'en', None, True, 'test_fewer_subs.srt')
self._assertCounts(video, {'en': 5, 'fr': 1})
def rollback(request, version):
is_writelocked = version.subtitle_language.is_writelocked
team_video = version.video.get_team_video()
if team_video and not can_rollback_language(request.user,
version.subtitle_language):
messages.error(
request,
_(u"You don't have permission to rollback "
"this language"))
elif is_writelocked:
messages.error(
request,
u'Can not rollback now, because someone is editing subtitles.')
elif not version.next_version():
messages.error(request,
message=u'Can not rollback to the last version')
else:
messages.success(request, message=u'Rollback successful')
version = rollback_to(version.video,
version.subtitle_language.language_code,
version_number=version.version_number,
rollback_author=request.user)
video_changed_tasks.delay(version.video.id, version.id)
return redirect(version.subtitle_language.get_absolute_url() +
'#revisions')
return redirect(version)
def test_rollback_authors(self):
v = self.video
en1, en2, en3 = self.en1, self.en2, self.en3
u1, us, anon = self.u1, self.u2, self.anon
# Rollbacks do not inherit the author of their sources.
rb = pipeline.rollback_to(v, 'en', 1)
self.assertEqual(rb.author.id, anon.id)
rb = pipeline.rollback_to(v, 'en', 2)
self.assertEqual(rb.author.id, anon.id)
# The rollback author can be explicitely given.
rb = pipeline.rollback_to(v, 'en', 3, rollback_author=u1)
self.assertEqual(rb.author.id, u1.id)
rb = pipeline.rollback_to(v, 'en', 2, rollback_author=u1)
self.assertEqual(rb.author.id, u1.id)
def test_rollback_parents(self):
v = self.video
de1 = pipeline.add_subtitles(v, 'de', [])
is1 = pipeline.add_subtitles(v, 'is', [])
is2 = pipeline.add_subtitles(v, 'is', [], parents=[de1])
is3 = pipeline.add_subtitles(v, 'is', [])
def _ids(s):
return set(i.id for i in s)
self.assertEqual(_ids(is2.parents.full()), _ids([is1, de1]))
# Rollbacks do not inherit the parents of their sources.
is4 = pipeline.rollback_to(v, 'is', 1)
self.assertEqual(_ids(is4.parents.full()), _ids([is3]))
is5 = pipeline.rollback_to(v, 'is', 2)
self.assertEqual(_ids(is5.parents.full()), _ids([is4]))
def test_basic_rollback(self):
v = self.video
en1, en2, en3 = self.en1, self.en2, self.en3
def _ids(s):
return set(i.id for i in s)
source = en1
rb = pipeline.rollback_to(v, 'en', 1)
self.assertTrue(rb.is_rollback())
self.assertEqual(rb.get_rollback_source(full=True), en1)
self.assertEqual(rb.video.id, source.video.id)
self.assertEqual(rb.subtitle_language.id, source.subtitle_language.id)
self.assertEqual(rb.language_code, source.language_code)
self.assertEqual(rb.get_subtitles(), source.get_subtitles())
self.assertEqual(rb.title, source.title)
self.assertEqual(rb.description, source.description)
self.assertEqual(_ids(rb.parents.full()), _ids([en3]))
def test_correct_lineage(self):
# German lineage for v1 should be en-v2
# for ge-v2 should be en-v3
# Create en-v1
en_v1_sset = create_subtitle_set()
self._edit_and_save(self.video, 'en', en_v1_sset)
en = self.video.newsubtitlelanguage_set.get(language_code='en')
en_v1 = en.subtitleversion_set.full().get(version_number=1)
self.assertEquals(en_v1.lineage, dict())
# create en-v2 with a changed timming
en_v2_sset = create_subtitle_set(5)
self._edit_and_save(self.video, 'en', en_v2_sset)
en_v2 = en.subtitleversion_set.full().get(version_number=2)
self.assertEquals(en_v2.lineage, {'en':1})
# create ge-v1 from en-v2
de_v1_sset = create_subtitle_set(3)
self._edit_and_save(self.video, 'de', de_v1_sset, 'en')
de = self.video.newsubtitlelanguage_set.get(language_code='de')
de_v1 = de.subtitleversion_set.full().get(version_number=1)
self.assertEquals(de_v1.lineage, {'en':2})
# rollback the en-v2 to en-v1
en_v3 = rollback_to(en_v1.subtitle_language.video,
en_v1.subtitle_language.language_code,
version_number=en_v1.version_number,
rollback_author=self.user_0)
# make sure this exists
en_v3 = en.subtitleversion_set.full().get(version_number=3)
# make sure we have the right lineages:
de_v2_sset = create_subtitle_set()
self._edit_and_save(self.video, 'de', de_v2_sset, 'en')
de_v2 = de.subtitleversion_set.full().get(version_number=2)
self.assertIn('en', de_v2.lineage)
self.assertEquals(de_v2.lineage['en'], 3)
self.assertEqual(en, de.get_translation_source_language())
def test_rollback_visibility(self):
v = self.video
# Fully public subtitle histories result in public rollbacks.
en1 = pipeline.add_subtitles(v, 'en', [])
en2 = pipeline.add_subtitles(v, 'en', [])
rb = pipeline.rollback_to(v, 'en', 1)
self.assertTrue(rb.is_public())
is1 = pipeline.add_subtitles(v, 'is', [], visibility='public')
is2 = pipeline.add_subtitles(v,
'is', [],
visibility='private',
visibility_override='public')
rb = pipeline.rollback_to(v, 'is', 1)
self.assertTrue(rb.is_public())
# Fully private subtitle histories result in private rollbacks.
de1 = pipeline.add_subtitles(v, 'de', [], visibility='private')
de2 = pipeline.add_subtitles(v, 'de', [], visibility='private')
rb = pipeline.rollback_to(v, 'de', 1)
self.assertTrue(rb.is_private())
fr1 = pipeline.add_subtitles(v,
'fr', [],
visibility_override='private')
fr2 = pipeline.add_subtitles(v,
'fr', [],
visibility_override='private')
rb = pipeline.rollback_to(v, 'fr', 1)
self.assertTrue(rb.is_private())
# Histories with a mix of public and private result in public rollbacks.
pt1 = pipeline.add_subtitles(v, 'pt', [], visibility='public')
pt2 = pipeline.add_subtitles(v, 'pt', [], visibility='private')
rb = pipeline.rollback_to(v, 'pt', 1)
self.assertTrue(rb.is_public())
pl1 = pipeline.add_subtitles(v, 'pl', [], visibility='private')
pl2 = pipeline.add_subtitles(v, 'pl', [], visibility='public')
rb = pipeline.rollback_to(v, 'pl', 1)
self.assertTrue(rb.is_public())
ja1 = pipeline.add_subtitles(v, 'ja', [], visibility='private')
ja2 = pipeline.add_subtitles(v, 'ja', [], visibility='public')
ja3 = pipeline.add_subtitles(v, 'ja', [], visibility='private')
rb = pipeline.rollback_to(v, 'ja', 1)
self.assertTrue(rb.is_public())
rb = pipeline.rollback_to(v, 'ja', 2)
self.assertTrue(rb.is_public())
rb = pipeline.rollback_to(v, 'ja', 3)
self.assertTrue(rb.is_public())
# Shut up, Pyflakes.
assert (en1 and en2 and is1 and is2 and de1 and de2 and fr1 and fr2
and pt1 and pt2 and pl1 and pl2 and ja1 and ja2 and ja3)
def make_rollback_to(subtitle_language, version_number):
return pipeline.rollback_to(subtitle_language.video,
subtitle_language.language_code,
version_number)
