def test_other_languages_changes(self): v = self._new_version() l = SubtitleLanguage(video=self.video, language='ru', is_original=False) l.save() self._new_version(l) alarms.check_other_languages_changes(v, ignore_statistic=True) self.assertEquals(len(mail.outbox), 1)
def _find_appropriate_language(self, video, language_code): language = video.subtitle_language(language_code) if not language: language = SubtitleLanguage( video=video, is_original=False, is_forked=True) language.language = language_code language.save() return language
def test_update_lp_for_sl(self): tv = TeamVideo.objects.get(id=2) sl = SubtitleLanguage( language='en', is_original=True, is_forked=False, is_complete=True, video=tv.video) sl.save() dl = SubtitleLanguage( language='es', is_original=False, is_forked=False, percent_done=40, standard_language=sl, video=tv.video) dl.save() tv = TeamVideo.objects.get(id=2) dl = SubtitleLanguage.objects.get(id=dl.id) dl.percent_done = 50 dl.save() lps = tv.searchable_language_pairs() self.assertEquals(len(settings.ALL_LANGUAGES) * 2 - 3, len(lps)) for lp in lps: match = LANGUAGEPAIR_RE.match(lp) if match.group(1) == 'en': if match.group(2) == 'es': self.assertEquals("M", match.group(3)) else: self.assertEquals("0", match.group(3)) elif match.group(1) == 'es': self.assertEquals("0", match.group(3))
def test_update_tvlp_for_sl(self): tv = TeamVideo.objects.get(id=2) sl = SubtitleLanguage( language='en', is_original=True, is_forked=False, is_complete=True, video=tv.video) sl.save() dl = SubtitleLanguage( language='es', is_original=False, is_forked=False, percent_done=40, standard_language=sl, video=tv.video) dl.save() tv = TeamVideo.objects.get(id=2) tv.update_team_video_language_pairs() dl = SubtitleLanguage.objects.get(id=dl.id) dl.percent_done = 50 dl.save() tv.update_team_video_language_pairs_for_sl(dl) tvlps = self._tvlp_query_set(tv) self.assertEquals(len(settings.ALL_LANGUAGES) * 2 - 2, len(tvlps)) for tvlp in tvlps: if tvlp.language_0 == 'en': if tvlp.language_1 == 'es': self.assertEquals(50, tvlp.percent_complete) else: self.assertEquals(0, tvlp.percent_complete) elif tvlp.language_0 == 'es': self.assertEquals(0, tvlp.percent_complete)
def test_update_tvlp_with_dep(self): tv = TeamVideo.objects.get(id=2) sl = SubtitleLanguage( language='en', is_original=True, is_forked=False, is_complete=True, video=tv.video) sl.save() dl = SubtitleLanguage( language='es', is_original=False, is_forked=False, percent_done=40, standard_language=sl, video=tv.video) dl.save() tv = TeamVideo.objects.get(id=2) tv.update_team_video_language_pairs() tvlps = self._tvlp_query_set(tv) self.assertEquals(len(settings.ALL_LANGUAGES) * 2 - 2, len(tvlps)) for tvlp in tvlps: if tvlp.language_0 == 'en': if tvlp.language_1 == 'es': self.assertEquals(40, tvlp.percent_complete) else: self.assertEquals(0, tvlp.percent_complete) elif tvlp.language_0 == 'es': self.assertEquals(0, tvlp.percent_complete)
def test_update_lp_with_dep(self): tv = TeamVideo.objects.get(id=2) sl = SubtitleLanguage(language='en', is_original=True, is_forked=False, is_complete=True, video=tv.video) sl.save() dl = SubtitleLanguage(language='es', is_original=False, is_forked=False, percent_done=40, standard_language=sl, video=tv.video) dl.save() tv = TeamVideo.objects.get(id=2) lps = tv.searchable_language_pairs() self.assertEquals(len(settings.ALL_LANGUAGES) * 2 - 3, len(lps)) for lp in lps: match = LANGUAGEPAIR_RE.match(lp) if match.group(1) == 'en': if match.group(2) == 'es': self.assertEquals('M', match.group(3)) else: self.assertEquals('0', match.group(3)) elif match.group(1) == 'es': self.assertEquals('0', match.group(3))
def save_subtitles(self, parser): video = self.cleaned_data['video'] key = str(uuid4()).replace('-', '') video._make_writelock(self.user, key) video.save() if not video.has_original_language(): self._save_original_language( video, self.cleaned_data['video_language']) language = video.subtitle_language(self.cleaned_data['language']) if not language: language = SubtitleLanguage(video=video, is_original=False, is_forked=True) language.language = self.cleaned_data['language'] language.save() try: old_version = language.subtitleversion_set.all()[:1].get() version_no = old_version.version_no + 1 except ObjectDoesNotExist: old_version = None version_no = 0 if not self.is_version_same(old_version, parser): version = SubtitleVersion( language=language, version_no=version_no, datetime_started=datetime.now(), user=self.user, note=u'Uploaded', is_forked=True, time_change=1, text_change=1) version.save() ids = [] for i, item in enumerate(parser): id = int(random.random()*10e12) while id in ids: id = int(random.random()*10e12) ids.append(id) caption = Subtitle(**item) caption.version = version caption.subtitle_id = str(id) caption.subtitle_order = i+1 caption.save() version.save() version.update_percent_done() language.update_complete_state() language.save() if language.is_original: video.update_complete_state() video.release_writelock() video.save() return language
def test_update_tvlp_no_dependent(self): tv = TeamVideo.objects.get(id=2) tv.update_team_video_language_pairs() # this video starts with no languages. self.assertEquals(0, self._tvlp_query_set(tv).count()) sl = SubtitleLanguage( language='en', is_original=True, is_forked=False, is_complete=False, video=tv.video) sl.save() tv = TeamVideo.objects.get(id=2) tv.update_team_video_language_pairs() # the language is not complete, so it's not a good source for translations. self.assertEquals(0, self._tvlp_query_set(tv).count()) sl = tv.video.subtitle_language('en') sl.is_complete = True sl.save() tv = TeamVideo.objects.get(id=2) tv.update_team_video_language_pairs() # complete, so now every language can be translated from this one. tvlps = self._tvlp_query_set(tv) self.assertEquals(len(settings.ALL_LANGUAGES) - 1, len(tvlps)) for tvlp in tvlps: self.assertEquals(0, tvlp.percent_complete)
def test_request_language_handler(self): ''' Test the signal handler which sets the requesters as language followers when a new (requested) language is created. ''' subrequest = self._create_requests(self.langs[2:3])[0] # Test if the user automatically starts following # a language if there is a pending request original = self.video.subtitle_language() newlang = SubtitleLanguage(video=self.video, language=subrequest.language, is_original=False, is_forked=False, standard_language=original) newlang.save() self.assertEqual(self.user, newlang.followers.all()[0]) # Test if subtitle request is marked as done newlang.is_complete = True newlang.save() subrequest = SubtitleRequest.objects.get(pk=subrequest.pk) self.assertEqual(subrequest.done, True)
def test_update_tvl(self): tv = TeamVideo.objects.get(id=2) sl = SubtitleLanguage( language='en', is_original=True, is_forked=False, is_complete=False, video=tv.video) sl.save() tmodels.TeamVideoLanguage.update(tv) tvls = tmodels.TeamVideoLanguage.objects.filter(team_video=tv) self.assertEquals(len(settings.ALL_LANGUAGES), len(tvls)) for tvl in tvls: self.assertFalse(tvl.is_complete) self.assertEquals(0, tvl.percent_done) sl = SubtitleLanguage.objects.get(id=sl.id) sl.is_complete = True sl.save() tv = TeamVideo.objects.get(id=2) tmodels.TeamVideoLanguage.update(tv) tvls = tmodels.TeamVideoLanguage.objects.filter(team_video=tv) self.assertEquals(len(settings.ALL_LANGUAGES), len(tvls)) for tvl in tvls: if tvl.language != 'en': self.assertFalse(tvl.is_complete) else: self.assertTrue(tvl.is_complete) self.assertEquals(0, tvl.percent_done)
def save(self): subtitles = self.cleaned_data["subtitles"] video = self.cleaned_data["video"] key = str(uuid4()).replace("-", "") video._make_writelock(self.user, key) video.save() language = video.subtitle_language() if not language: language = SubtitleLanguage(video=video, is_original=True, is_complete=True) language.save() latest_captions = language.latest_version() if latest_captions is None: version_no = 0 else: version_no = latest_captions.version_no + 1 version = SubtitleVersion( language=language, version_no=version_no, datetime_started=datetime.now(), user=self.user, note=u"Uploaded" ) version.save() text = subtitles.read() parser = self._get_parser(subtitles.name)(force_unicode(text, chardet.detect(text)["encoding"])) ids = [] for i, item in enumerate(parser): id = int(random.random() * 10e12) while id in ids: id = int(random.random() * 10e12) ids.append(id) caption = Subtitle(**item) caption.version = version caption.subtitle_id = str(id) caption.sub_order = i + 1 caption.save() version.finished = True version.save() video.release_writelock() video.save()
def test_languages_mark_incomplete(self): ''' Test if already completed subtitles are marked as incomplete on a subtitle request ''' langs = self.langs[3:] original = self.video.subtitle_language() lang = SubtitleLanguage(video=self.video, language=langs[0], is_original=False, is_forked=False, is_complete=True, standard_language=original) lang.save() self._create_requests(langs)[0] lang = SubtitleLanguage.objects.get(pk=lang.pk) self.assertEqual(False, lang.is_complete)
def test_languages_mark_incomplete(self): ''' Test if already completed subtitles are marked as incomplete on a subtitle request ''' langs = self.langs[3:] original = self.video.subtitle_language() lang = SubtitleLanguage( video=self.video, language=langs[0], is_original=False, is_forked=False, is_complete=True, standard_language=original) lang.save() self._create_requests(langs)[0] lang = SubtitleLanguage.objects.get(pk=lang.pk) self.assertEqual(False, lang.is_complete)
def test_request_language_handler(self): ''' Test the signal handler which sets the requesters as language followers when a new (requested) language is created. ''' subrequest = self._create_requests(self.langs[2:3])[0] # Test if the user automatically starts following # a language if there is a pending request original = self.video.subtitle_language() newlang = SubtitleLanguage( video=self.video, language=subrequest.language, is_original=False, is_forked=False, standard_language=original) newlang.save() self.assertEqual(self.user, newlang.followers.all()[0]) # Test if subtitle request is marked as done newlang.is_complete = True newlang.save() subrequest = SubtitleRequest.objects.get(pk=subrequest.pk) self.assertEqual(subrequest.done, True)
def _save_original_language(self, video, video_language): original_language = video.subtitle_language() if original_language: if original_language.language: try: language_exists = video.subtitlelanguage_set.exclude(pk=original_language.pk) \ .get(language=video_language) original_language.is_original = False original_language.save() language_exists.is_original = True language_exists.save() except ObjectDoesNotExist: original_language.language = video_language original_language.save() else: try: language_exists = video.subtitlelanguage_set.exclude(pk=original_language.pk) \ .get(language=video_language) latest_version = original_language.latest_version() if latest_version: last_no = latest_version.version_no else: last_no = 0 for version in language_exists.subtitleversion_set.all(): version.language = original_language last_no += 1 version.version_no = last_no version.save() language_exists.delete() except ObjectDoesNotExist: pass original_language.language = video_language original_language.save() else: #original_language always exists, but... try: language_exists = video.subtitlelanguage_set.get( language=video_language) language_exists.is_original = True language_exists.save() except ObjectDoesNotExist: original_language = SubtitleLanguage() original_language.language = video_language original_language.is_original = True original_language.video = video original_language.save()
def test_moderated_subs_reject_one(self): url = reverse("teams:detail", kwargs={"slug": self.team.slug}) response = self.client.get(url) add_moderation(self.video, self.team, self.user) self._login(is_moderator=True) self.client.get("\en\faq") lang = self.video.subtitle_language() [ self._make_subs(lang, 5) for x in xrange(0, 3)] self.assertEquals(self.team.get_pending_moderation().count(), 3) lang = SubtitleLanguage(video=self.video, language="pt", title="a") lang.save() [ self._make_subs(lang, 5) for x in xrange(0, 3)] self.assertEquals(self.team.get_pending_moderation().count(), 6) versions = self.team.get_pending_moderation() version = versions[0] url = reverse("moderation:revision-approve", kwargs={ "team_id":self.team.id, "version_id":version.pk}) response = self.client.post(url, {},follow=True) self.assertEquals(response.status_code, 200) self.assertEquals(self.team.get_pending_moderation().count(), 5) version = SubtitleVersion.objects.get(pk=version.pk) self.assertEquals(version.moderation_status,APPROVED)
def _create_trans(video, latest_version=None, lang_code=None, forked=False): translation = SubtitleLanguage() translation.video = video translation.language = lang_code translation.is_original = False translation.is_forked = forked if not forked: translation.standard_language = video.subtitle_language() translation.save() v = SubtitleVersion() v.language = translation if latest_version: v.version_no = latest_version.version_no + 1 else: v.version_no = 1 v.datetime_started = datetime.now() v.save() if latest_version is not None: for s in latest_version.subtitle_set.all(): s.duplicate_for(v).save() return translation
def test_update_sl(self): tv = TeamVideo.objects.get(id=2) sublang = SubtitleLanguage(language='en', is_original=True, is_forked=False, is_complete=False, video=tv.video) sublang.save() sls = tv.searchable_languages() self.assertEquals(len(settings.ALL_LANGUAGES), len(sls)) sublang = SubtitleLanguage.objects.get(id=sublang.id) sublang.is_complete = True sublang.save() tv = TeamVideo.objects.get(id=2) sls = tv.searchable_languages() self.assertEquals(len(settings.ALL_LANGUAGES) - 1, len(sls))
def _save_original_language(self, video, video_language): original_language = video.subtitle_language() if original_language: if original_language.language: try: language_exists = video.subtitlelanguage_set.exclude(pk=original_language.pk) \ .get(language=video_language) original_language.is_original = False original_language.save() language_exists.is_original = True language_exists.save() except ObjectDoesNotExist: original_language.language = video_language original_language.save() else: try: language_exists = video.subtitlelanguage_set.exclude(pk=original_language.pk) \ .get(language=video_language) latest_version = original_language.latest_version() if latest_version: last_no = latest_version.version_no else: last_no = 0 for version in language_exists.subtitleversion_set.all(): version.language = original_language last_no += 1 version.version_no = last_no version.save() language_exists.delete() except ObjectDoesNotExist: pass original_language.language = video_language original_language.save() else: #original_language always exists, but... try: language_exists = video.subtitlelanguage_set.get(language=video_language) language_exists.is_original = True language_exists.save() except ObjectDoesNotExist: original_language = SubtitleLanguage() original_language.language = video_language original_language.is_original = True original_language.video = video original_language.save()
def test_moderated_subs_pending_count(self): add_moderation(self.video, self.team, self.user) lang = self.video.subtitle_language() [ self._make_subs(lang, 5) for x in xrange(0, 3)] self.assertEquals(self.team.get_pending_moderation().count(), 3) lang = SubtitleLanguage(video=self.video, language="pt", title="a") lang.save() [ self._make_subs(lang, 5) for x in xrange(0, 3)] self.assertEquals(self.team.get_pending_moderation().count(), 6) # make sure pending count is for only one team tv = TeamVideo.objects.exclude(team=self.team).filter(video__moderated_by__isnull=True)[0] o, c = TeamMember.objects.get_or_create(user=self.auth_user, team=tv.team) o.role=TeamMember.ROLE_MANAGER o.save() new_team = tv.team add_moderation(tv.video, tv.team, self.auth_user) lang = SubtitleLanguage(video=tv.video, language="pt", title="a") lang.save() [ self._make_subs(lang, 5) for x in xrange(0, 3)] self.assertEquals(self.team.get_pending_moderation().count(), 6) self.assertEquals(tv.team.get_pending_moderation().count(), 3)
def legacy_history(request, video, lang=None): """ In the old days we allowed only one translation per video. Therefore video urls looked like /vfjdh2/en/ Now that this constraint is removed we need to redirect old urls to the new view, that needs """ try: language = video.subtitle_language(lang) if language is None: raise SubtitleLanguage.DoesNotExist("No such language") except SubtitleLanguage.DoesNotExist: raise Http404() return HttpResponseRedirect( reverse("videos:translation_history", kwargs={ 'video_id': video.video_id, 'lang_id': language.pk, 'lang': language.language, }))
def setUp(self): self.video = Video.objects.all()[:1].get() self.original_language = self.video.subtitle_language() latest_version = self.original_language.latest_version() translation = SubtitleLanguage() translation.video = self.video translation.language = 'uk' translation.is_original = False translation.is_forked = False translation.save() self.translation = translation v = SubtitleVersion() v.language = translation v.datetime_started = datetime.now() v.save() self.translation_version = v for s in latest_version.subtitle_set.all(): s.duplicate_for(v).save()
def _import_video(self, video_url, videoid, title, description, thumbnail, videosrt): videoid_match = VIDEOID_RE.search(videoid) videoid = videoid_match.group(1) video_type = YoutubeVideoType( 'http://www.youtube.com/watch?v={0}'.format(videoid)) try: video_url_obj = VideoUrl.objects.get( url=video_type.convert_to_video_url()) video = video_url_obj.video except ObjectDoesNotExist: video_url_obj = None video = Video() video.youtube_videoid = videoid video.title = title video.description = description if video_type.entry.media.duration: video.duration = int(video_type.entry.media.duration.seconds) video.thumbnail = thumbnail video.save() Action.create_video_handler(video) if videosrt: self._import_srt(video, videosrt) else: SubtitleLanguage(video=video, language='en', is_original=True, is_forked=True).save() if not video_url_obj: video_url_obj = VideoUrl(videoid=videoid, url=video_type.convert_to_video_url(), type=video_type.abbreviation, original=True, primary=True, video=video) video_url_obj.save() self._save_alternate_url(video, video_url)
def forwards(self, orm): if db.dry_run: return try: from videos.models import Video, SubtitleLanguage except ImportError: return try: Video.widget_views_counter.r.ping() except ConnectionError: if settings.DEBUG: return raise Exception('Redis server is unavailable. You can ignore this migration with: python manage.py migrate videos 0068 --fake, but all statistic data will be lost.') for obj in orm.Video.objects.all(): Video.subtitles_fetched_counter(obj.video_id).val = obj.subtitles_fetched_count Video.widget_views_counter(obj.video_id).val = obj.widget_views_count for obj in orm.SubtitleLanguage.objects.all(): SubtitleLanguage.subtitles_fetched_counter(obj.pk).val = obj.subtitles_fetched_count
def test_update_sl(self): tv = TeamVideo.objects.get(id=2) sublang = SubtitleLanguage( language='en', is_original=True, is_forked=False, is_complete=False, video=tv.video) sublang.save() sls = tv.searchable_languages() self.assertEquals(len(settings.ALL_LANGUAGES), len(sls)) sublang = SubtitleLanguage.objects.get(id=sublang.id) sublang.is_complete = True sublang.save() tv = TeamVideo.objects.get(id=2) sls = tv.searchable_languages() self.assertEquals(len(settings.ALL_LANGUAGES) - 1, len(sls))
def test_update_lp_no_dependent(self): tv = TeamVideo.objects.get(id=2) # this video starts with no languages. self.assertEquals(0, len(tv.searchable_language_pairs())) sl = SubtitleLanguage(language='en', is_original=True, is_forked=False, is_complete=False, video=tv.video) sl.save() tv = TeamVideo.objects.get(id=2) self.assertEquals(0, len(tv.searchable_language_pairs())) sl = tv.video.subtitle_language('en') sl.is_complete = True sl.save() tv = TeamVideo.objects.get(id=2) lps = tv.searchable_language_pairs() self.assertEquals(len(settings.ALL_LANGUAGES) - 1, len(lps)) # we expect each string to end in "_0" to indicate zero completion. for lp in lps: self.assertEquals("0", LANGUAGEPAIR_RE.match(lp).group(3))
def test_update_lp_no_dependent(self): tv = TeamVideo.objects.get(id=2) # this video starts with no languages. self.assertEquals(0, len(tv.searchable_language_pairs())) sl = SubtitleLanguage( language='en', is_original=True, is_forked=False, is_complete=False, video=tv.video) sl.save() tv = TeamVideo.objects.get(id=2) self.assertEquals(0, len(tv.searchable_language_pairs())) sl = tv.video.subtitle_language('en') sl.is_complete = True sl.save() tv = TeamVideo.objects.get(id=2) lps = tv.searchable_language_pairs() self.assertEquals(len(settings.ALL_LANGUAGES) - 1, len(lps)) # we expect each string to end in "_0" to indicate zero completion. for lp in lps: self.assertEquals("0", LANGUAGEPAIR_RE.match(lp).group(3))
def save_subtitles(self, parser): video = self.cleaned_data['video'] key = str(uuid4()).replace('-', '') video._make_writelock(self.user, key) video.save() if not video.has_original_language(): self._save_original_language(video, self.cleaned_data['video_language']) language = video.subtitle_language(self.cleaned_data['language']) if not language: language = SubtitleLanguage(video=video, is_original=False, is_forked=True) language.language = self.cleaned_data['language'] language.save() try: old_version = language.subtitleversion_set.all()[:1].get() version_no = old_version.version_no + 1 except ObjectDoesNotExist: old_version = None version_no = 0 if not self.is_version_same(old_version, parser): version = SubtitleVersion(language=language, version_no=version_no, datetime_started=datetime.now(), user=self.user, note=u'Uploaded', is_forked=True, time_change=1, text_change=1) version.save() ids = [] for i, item in enumerate(parser): id = int(random.random() * 10e12) while id in ids: id = int(random.random() * 10e12) ids.append(id) caption = Subtitle(**item) caption.version = version caption.subtitle_id = str(id) caption.subtitle_order = i + 1 caption.save() version.save() version.update_percent_done() language.update_complete_state() language.save() if language.is_original: video.update_complete_state() video.release_writelock() video.save() return language
def test_moderated_subs_approve_one(self): video = Video.objects.get(pk=4) tv = TeamVideo(video=video, team=self.team,added_by=self.user) tv.save() url = reverse("teams:detail", kwargs={"slug": self.team.slug}) response = self.client.get(url) add_moderation(video, self.team, self.user) self._login(is_moderator=True) self.client.get("\en\faq") lang = video.subtitle_language() [ self._make_subs(lang, 5) for x in xrange(0, 3)] self.assertEquals(self.team.get_pending_moderation().count(), 3) lang = SubtitleLanguage(video=video, language="pt", title="a", standard_language=lang) lang.save() [ self._make_subs(lang, 5) for x in xrange(0, 3)] # we can see the unmoderated sub on the website, response = self.client.get(reverse("videos:translation_history", kwargs={ 'video_id':video.video_id, 'lang':lang.language, 'lang_id':lang.id })) versions = SubtitleVersion.objects.filter(language=lang) latest_version = lang.latest_version(public_only=False) #lang.subtitleversion_set.all()[0] subs = response.context['last_version'].subtitle_set.all() self.assertEquals(latest_version, response.context['last_version']) self.assertTrue(subs[0].subtitle_text.startswith("vno:2 Sub 0 ")) self.assertTrue(len(subs)) self.assertEquals(self.team.get_pending_moderation().count(), 6) versions = self.team.get_pending_moderation() version = versions[0] # after moderation it should not be visible on the widget subs = self._call_rpc_method("fetch_subtitles", lang.video.video_id, lang.pk) self.assertFalse(subs) url = reverse("moderation:revision-approve", kwargs={ "team_id":self.team.id, "version_id":version.pk} ) response = self.client.post(url, {},follow=True, HTTP_X_REQUESTED_WITH='XMLHttpRequest') self.assertEquals(response.status_code, 200) data = json.loads(response.content) self.assertTrue(data["success"]) self.team = refresh_obj(self.team) self.assertEquals(self.team.get_pending_moderation().count(), 5) version = SubtitleVersion.objects.get(pk=version.pk) self.assertEquals(version.moderation_status,APPROVED) response = self.client.get(reverse("videos:translation_history", kwargs={ 'video_id':video.video_id, 'lang':lang.language, 'lang_id':lang.id })) sub_1 = response.context['last_version'].subtitle_set.all() self.assertTrue(len(sub_1)) widget_res = self._call_rpc_method("fetch_subtitles", version.video.video_id, version.language.pk) self.assertTrue(widget_res) self.assertTrue(widget_res["subtitles"]) sub = widget_res["subtitles"][0] self.assertTrue(sub["text"].startswith("vno:2 Sub 0 "))
def test_subtitle_language_save(self): self.assertEqual(self.video.complete_date, None) self.assertEqual(self.video.subtitlelanguage_set.count(), 1) self.language.is_complete = True self.language.save() self.video = Video.objects.get(pk=self.video.pk) self.assertNotEqual(self.video.complete_date, None) self.language.is_complete = False self.language.save() self.video = Video.objects.get(pk=self.video.pk) self.assertEqual(self.video.complete_date, None) #add one more SubtitleLanguage l = SubtitleLanguage(video=self.video) l.is_original = False l.is_complete = True l.save() self.video = Video.objects.get(pk=self.video.pk) self.assertNotEqual(self.video.complete_date, None) self.language.is_complete = True self.language.save() self.video = Video.objects.get(pk=self.video.pk) self.assertNotEqual(self.video.complete_date, None) l.is_complete = False l.save() self.video = Video.objects.get(pk=self.video.pk) self.assertNotEqual(self.video.complete_date, None) self.language.is_complete = False self.language.save() self.video = Video.objects.get(pk=self.video.pk) self.assertEqual(self.video.complete_date, None) self.language.is_complete = True self.language.save() self.video = Video.objects.get(pk=self.video.pk) self.assertNotEqual(self.video.complete_date, None) l.is_complete = True l.save() self.video = Video.objects.get(pk=self.video.pk) self.assertNotEqual(self.video.complete_date, None) self.language.delete() self.video = Video.objects.get(pk=self.video.pk) self.assertNotEqual(self.video.complete_date, None) l.delete() self.video = Video.objects.get(pk=self.video.pk) self.assertEqual(self.video.complete_date, None)