def test_last_version_never_rejected(self):
tv = self.team.teamvideo_set.all()[0]
add_moderation(tv.video, tv.team, self.user)
self.assertEquals(tv.team.get_pending_moderation().count() , 0)
versions = self._create_versions( tv.video.subtitle_language(), num_versions=2)
approve_version(versions[1], tv.team, self.user)
remove_moderation(tv.video, tv.team, self.user)
version = refresh_obj(versions[0])
self.assertEquals(version.moderation_status , UNMODERATED)
version = refresh_obj(versions[1])
self.assertEquals(version.moderation_status , UNMODERATED)
def test_team_video_delete(self):
#this test can fail only on MySQL
team = Team.objects.get(pk=1)
tv = team.teamvideo_set.exclude(video__subtitlelanguage__language='')[:1].get()
# create a few languages with subs
from videos.tests import create_langs_and_versions
video = tv.video
video.is_public = False
video.moderated_by = team
video.save()
langs = ["en" ,"es", 'fr', 'pt_br']
versions = create_langs_and_versions(video, langs)
for v in versions:
v.moderation_status = MODERATION.WAITING_MODERATION
tv.delete()
try:
TeamVideo.objects.get(pk=tv.pk)
self.fail()
except TeamVideo.DoesNotExist:
pass
video = refresh_obj(video)
for lang in langs:
l = video.subtitle_language(lang)
self.assertTrue(l.version())
self.assertTrue(l.has_version)
self.assertTrue(video.is_public)
self.assertEqual(video.moderated_by, None)
def test_contribuitors_do_bypass_moderation(self):
lang = self.video.subtitle_language()
member, created = TeamMember.objects.get_or_create(user=self.user, team=self.team)
member.role=TeamMember.ROLE_MANAGER
member.save()
add_moderation(self.video, self.team, self.user)
joe_doe = User(username="******", password="******", email="*****@*****.**")
joe_doe.save()
joe_member, c = TeamMember.objects.get_or_create(user=joe_doe, team=self.team)
joe_member.save()
v0 = self._create_versions(lang, 1, user=joe_doe)[0]
self.assertEquals(v0.moderation_status,WAITING_MODERATION)
joe_member.promote_to_contributor()
joe_doe = refresh_obj(joe_doe)
self.assertTrue(self.team.is_contributor(joe_doe, authenticated=False))
v1 = self._create_versions(lang, 1, user=joe_doe)[0]
metadata_manager.update_metadata(self.video.pk)
v1 = refresh_obj(v1)
self.assertEquals(v1.moderation_status, APPROVED)
def _create_versions(self, lang, num_versions=1, num_subs=None, user=None):
versions = []
lang = refresh_obj(lang)
for num in xrange(0, num_versions):
v = SubtitleVersion(language=lang)
if lang.subtitleversion_set.all().count() > 0:
v.version_no = lang.subtitleversion_set.all()[0].version_no + 1
else:
v.version_no = 1
v.datetime_started = datetime.now()
v.user = user or self.user or User.objects.all()[0]
v.save()
versions.append(v)
for i in xrange(0,3):
s = Subtitle(version=v, subtitle_text="%s%s%s" % (lang.pk, v.version_no, i), subtitle_order=i, subtitle_id="%s-%s-" % (v.pk, i))
s.save()
return versions
def test_promote_user(self):
other_user = User.objects.exclude(pk=self.user.pk)[:1].get()
user_tm = TeamMember(team=self.team, user=self.user)
user_tm.save()
other_user_tm = TeamMember(team=self.team, user=other_user)
other_user_tm.save()
self.assertEqual(other_user_tm.role, TeamMember.ROLE_CONTRIBUTOR)
self.assertEqual(user_tm.role, TeamMember.ROLE_CONTRIBUTOR)
response = self.rpc.promote_user(self.team.pk, other_user_tm.pk, TeamMember.ROLE_MANAGER, AnonymousUser())
if not isinstance(response, Error):
self.fail('Anonymouse user is not member of team')
response = self.rpc.promote_user(self.team.pk, other_user_tm.pk, TeamMember.ROLE_MANAGER, self.user)
if not isinstance(response, Error):
self.fail('User should be manager')
user_tm.role = TeamMember.ROLE_MANAGER
user_tm.save()
NEW_ROLE = TeamMember.ROLE_CONTRIBUTOR
response = self.rpc.promote_user(self.team.pk, other_user_tm.pk, NEW_ROLE, self.user)
self.assertTrue(isinstance(response, Msg))
other_user_tm = refresh_obj(other_user_tm)
self.assertEqual(other_user_tm.role, NEW_ROLE)
response = self.rpc.promote_user(self.team.pk, user_tm.pk, TeamMember.ROLE_CONTRIBUTOR, self.user)
if not isinstance(response, Error):
self.fail('Can\'t promote yourself')
response = self.rpc.promote_user(self.team.pk, other_user_tm.pk, 'undefined role 123456', self.user)
if not isinstance(response, Error):
self.fail('Incorrect role')
response = self.rpc.promote_user(self.team.pk, 123456, TeamMember.ROLE_MANAGER, self.user)
if not isinstance(response, Error):
self.fail('Undefined team member')
undefined_team_pk = 123456
self.assertFalse(Team.objects.filter(pk=undefined_team_pk))
response = self.rpc.promote_user(undefined_team_pk, other_user_tm.pk, TeamMember.ROLE_MANAGER, self.user)
if not isinstance(response, Error):
self.fail('Undefined team')
def test_promote_user(self):
other_user = User.objects.exclude(pk=self.user.pk)[:1].get()
user_tm = TeamMember(team=self.team, user=self.user)
user_tm.save()
other_user_tm = TeamMember(team=self.team, user=other_user)
other_user_tm.save()
self.assertEqual(other_user_tm.role, TeamMember.ROLE_MEMBER)
self.assertEqual(user_tm.role, TeamMember.ROLE_MEMBER)
response = self.rpc.promote_user(self.team.pk, other_user_tm.pk, TeamMember.ROLE_MANAGER, AnonymousUser())
if not isinstance(response, Error):
self.fail('Anonymouse user is not member of team')
response = self.rpc.promote_user(self.team.pk, other_user_tm.pk, TeamMember.ROLE_MANAGER, self.user)
if not isinstance(response, Error):
self.fail('User should be manager')
user_tm.role = TeamMember.ROLE_MANAGER
user_tm.save()
NEW_ROLE = TeamMember.ROLE_CONTRIBUTOR
response = self.rpc.promote_user(self.team.pk, other_user_tm.pk, NEW_ROLE, self.user)
self.assertTrue(isinstance(response, Msg))
other_user_tm = refresh_obj(other_user_tm)
self.assertEqual(other_user_tm.role, NEW_ROLE)
response = self.rpc.promote_user(self.team.pk, user_tm.pk, TeamMember.ROLE_CONTRIBUTOR, self.user)
if not isinstance(response, Error):
self.fail('Can\'t promote yourself')
response = self.rpc.promote_user(self.team.pk, other_user_tm.pk, 'undefined role 123456', self.user)
if not isinstance(response, Error):
self.fail('Incorrect role')
response = self.rpc.promote_user(self.team.pk, 123456, TeamMember.ROLE_MANAGER, self.user)
if not isinstance(response, Error):
self.fail('Undefined team member')
undefined_team_pk = 123456
self.assertFalse(Team.objects.filter(pk=undefined_team_pk))
response = self.rpc.promote_user(undefined_team_pk, other_user_tm.pk, TeamMember.ROLE_MANAGER, self.user)
if not isinstance(response, Error):
self.fail('Undefined team')
def test_views(self):
self.client.login(**self.auth)
#------- create ----------
response = self.client.get(reverse("teams:create"))
self.failUnlessEqual(response.status_code, 200)
data = {
"description": u"",
"video_url": u"",
"membership_policy": u"4",
"video_policy": u"1",
"logo": u"",
"slug": u"new-team",
"name": u"New team"
}
response = self.client.post(reverse("teams:create"), data)
self.failUnlessEqual(response.status_code, 302)
team = Team.objects.get(slug=data['slug'])
#---------- index -------------
response = self.client.get(reverse("teams:index"))
self.failUnlessEqual(response.status_code, 200)
response = self.client.get(reverse("teams:index"), {'q': 'vol'})
self.failUnlessEqual(response.status_code, 200)
data = {
"q": u"vol",
"o": u"date"
}
response = self.client.get(reverse("teams:index"), data)
self.failUnlessEqual(response.status_code, 200)
response = self.client.get(reverse("teams:index"), {'o': 'my'})
self.failUnlessEqual(response.status_code, 200)
#---------- edit ------------
url = reverse("teams:edit", kwargs={"slug": team.slug})
response = self.client.get(url)
self.failUnlessEqual(response.status_code, 200)
data = {
"logo": open(path.join(settings.MEDIA_ROOT, "test/71600102.jpg"), "rb")
}
url = reverse("teams:edit_logo", kwargs={"slug": team.slug})
response = self.client.post(url, data)
self.failUnlessEqual(response.status_code, 200)
team = Team.objects.get(pk=team.pk)
self.assertTrue(team.logo)
data = {
"name": u"New team",
"video_url": u"http://www.youtube.com/watch?v=tGsHDUdw8As",
"membership_policy": u"4",
"video_policy": u"1",
"description": u"",
"logo": open(path.join(settings.MEDIA_ROOT, "test/71600102.jpg"), "rb")
}
url = reverse("teams:edit", kwargs={"slug": team.slug})
response = self.client.post(url, data)
self.failUnlessEqual(response.status_code, 302)
video = Video.objects.get(videourl__type=VIDEO_TYPE_YOUTUBE, videourl__videoid='tGsHDUdw8As')
team = Team.objects.get(pk=team.pk)
self.assertEqual(team.video, video)
#-------------- edit members ---------------
url = reverse("teams:edit_members", kwargs={"slug": team.slug})
response = self.client.get(url)
self.failUnlessEqual(response.status_code, 200)
#-------------- edit videos -----------------
url = reverse("teams:edit_videos", kwargs={"slug": team.slug})
response = self.client.get(url)
self.failUnlessEqual(response.status_code, 200)
url = reverse("teams:edit", kwargs={"slug": "volunteer1"})
response = self.client.get(url)
self.failUnlessEqual(response.status_code, 404)
self.client.logout()
url = reverse("teams:edit", kwargs={"slug": "volunteer"})
response = self.client.get(url)
self.failUnlessEqual(response.status_code, 302)
self.client.login(**self.auth)
#-------------- applications ----------------
url = reverse("teams:applications", kwargs={"slug": team.slug})
response = self.client.get(url)
self.failUnlessEqual(response.status_code, 200)
#------------ detail ---------------------
url = reverse("teams:detail", kwargs={"slug": team.slug})
response = self.client.get(url)
self.failUnlessEqual(response.status_code, 200)
url = reverse("teams:detail", kwargs={"slug": team.pk})
response = self.client.get(url)
self.failUnlessEqual(response.status_code, 200)
url = reverse("teams:detail", kwargs={"slug": team.slug})
response = self.client.get(url)
self.failUnlessEqual(response.status_code, 200)
url = reverse("teams:detail", kwargs={"slug": team.slug})
response = self.client.get(url, {'q': 'Lions'})
self.failUnlessEqual(response.status_code, 200)
url = reverse("teams:detail", kwargs={"slug": team.slug})
response = self.client.get(url, {'q': 'empty result'})
self.failUnlessEqual(response.status_code, 200)
#------------ detail members -------------
url = reverse("teams:detail_members", kwargs={"slug": team.slug})
response = self.client.get(url)
self.failUnlessEqual(response.status_code, 200)
url = reverse("teams:detail_members", kwargs={"slug": team.slug})
response = self.client.get(url, {'q': 'test'})
self.failUnlessEqual(response.status_code, 200)
#-------------members activity ---------------
#Deprecated
#url = reverse("teams:members_actions", kwargs={"slug": team.slug})
#response = self.client.get(url)
#self.failUnlessEqual(response.status_code, 200)
#------------- add video ----------------------
self.client.login(**self.auth)
data = {
"languages-MAX_NUM_FORMS": u"",
"description": u"",
"language": u"en",
"title": u"",
"languages-0-language": u"be",
"languages-0-id": u"",
"languages-TOTAL_FORMS": u"1",
"video_url": u"http://www.youtube.com/watch?v=Hhgfz0zPmH4&feature=grec_index",
"thumbnail": u"",
"languages-INITIAL_FORMS": u"0"
}
tv_len = team.teamvideo_set.count()
url = reverse("teams:add_video", kwargs={"slug": team.slug})
response = self.client.post(url, data)
self.assertEqual(tv_len+1, team.teamvideo_set.count())
self.assertRedirects(response, reverse("teams:team_video", kwargs={"team_video_pk": 3}))
#-------edit team video -----------------
team = Team.objects.get(pk=1)
tv = team.teamvideo_set.get(pk=1)
tv.title = ''
tv.description = ''
tv.save()
data = {
"languages-MAX_NUM_FORMS": u"",
"languages-INITIAL_FORMS": u"0",
"title": u"change title",
"languages-0-language": u"el",
"languages-0-id": u"",
"languages-TOTAL_FORMS": u"1",
"languages-0-completed": u"on",
"thumbnail": u"",
"description": u"and description"
}
url = reverse("teams:team_video", kwargs={"team_video_pk": tv.pk})
response = self.client.post(url, data)
self.assertRedirects(response, reverse("teams:team_video", kwargs={"team_video_pk": tv.pk}))
tv = team.teamvideo_set.get(pk=1)
self.assertEqual(tv.title, u"change title")
self.assertEqual(tv.description, u"and description")
#-----------delete video -------------
url = reverse("teams:remove_video", kwargs={"team_video_pk": tv.pk})
response = self.client.post(url)
self.failUnlessEqual(response.status_code, 200)
try:
team.teamvideo_set.get(pk=1)
self.fail()
except ObjectDoesNotExist:
pass
#----------inviting to team-----------
user2 = User.objects.get(username="******")
TeamMember.objects.filter(user=user2, team=team).delete()
data = {
"username": user2.username,
"note": u"asd",
"team_id": team.pk
}
response = self.client.post(reverse("teams:invite"), data)
self.failUnlessEqual(response.status_code, 200)
invite = Invite.objects.get(user__username=user2.username, team=team)
ct = ContentType.objects.get_for_model(Invite)
Message.objects.filter(object_pk=invite.pk, content_type=ct, user=user2)
members_count = team.members.count()
self.client.login(username = user2.username, password ='******')
url = reverse("teams:accept_invite", kwargs={"invite_pk": invite.pk})
response = self.client.get(url)
self.assertEqual(members_count+1, team.members.count())
self.client.login(**self.auth)
url = reverse("teams:edit_members", kwargs={"slug": team.slug})
response = self.client.get(url)
self.failUnlessEqual(response.status_code, 200)
data = {
"ot": u"desc",
"page": u"1",
"o": u"username"
}
url = reverse("teams:edit_members", kwargs={"slug": team.slug})
response = self.client.get(url, data)
self.failUnlessEqual(response.status_code, 200)
tm,c = TeamMember.objects.get_or_create(user=self.user, team=team)
tm.promote_to_manager()
self.assertFalse(team.is_manager(user2))
url = reverse("teams:promote_member", kwargs={"user_pk": user2.pk, "slug": team.slug})
response = self.client.get(url)
self.assertRedirects(response, reverse("teams:edit_members", kwargs={"slug": team.slug}))
team = refresh_obj(team)
self.assertTrue(team.is_manager(user2))
url = reverse("teams:promote_member", kwargs={"user_pk": user2.pk, "slug": team.slug})
response = self.client.post(url, {"role":TeamMember.ROLE_MEMBER})
self.assertRedirects(response, reverse("teams:edit_members", kwargs={"slug": team.slug}))
self.assertFalse(team.is_manager(user2))
url = reverse("teams:remove_member", kwargs={"user_pk": user2.pk, "slug": team.slug})
response = self.client.post(url)
self.failUnlessEqual(response.status_code, 200)
self.assertFalse(team.is_member(user2))
url = reverse("teams:completed_videos", kwargs={"slug": team.slug})
response = self.client.post(url)
self.failUnlessEqual(response.status_code, 200)
url = reverse("teams:videos_actions", kwargs={"slug": team.slug})
response = self.client.post(url)
self.failUnlessEqual(response.status_code, 200)
self.client.login()
TeamMember.objects.filter(user=self.user, team=team).delete()
self.assertFalse(team.is_member(self.user))
url = reverse("teams:join_team", kwargs={"slug": team.slug})
response = self.client.post(url)
self.failUnlessEqual(response.status_code, 302)
self.assertTrue(team.is_member(self.user))
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 "))
