def setup_users(self):
# make a bunch of users to subtitle/review the work
subtitlers = [
test_factories.create_user(pay_rate_code='S%s' % i)
for i in xrange(3)
]
reviewers = [
test_factories.create_user(pay_rate_code='R%s' % i)
for i in xrange(2)
]
for u in subtitlers:
test_factories.create_team_member(user=u,
team=self.team,
role=ROLE_CONTRIBUTOR)
for u in reviewers:
test_factories.create_team_member(user=u,
team=self.team,
role=ROLE_MANAGER)
self.subtitler_iter = itertools.cycle(subtitlers)
self.reviewer_iter = itertools.cycle(reviewers)
self.admin = test_factories.create_team_member(team=self.team,
role=ROLE_ADMIN).user
self.users = dict((unicode(u), u) for u in subtitlers + reviewers)
self.users[unicode(self.admin)] = self.admin
def test_permissions(self):
self.check_user_perm(test_factories.create_user(), False)
self.check_user_perm(test_factories.create_user(is_staff=True), True)
for role in (ROLE_ADMIN, ROLE_OWNER):
user = test_factories.create_user()
test_factories.create_team_member(self.team, user, role=role)
self.check_user_perm(user, True)
for role in (ROLE_CONTRIBUTOR, ROLE_MANAGER):
user = test_factories.create_user()
test_factories.create_team_member(self.team, user, role=role)
self.check_user_perm(user, False)
def test_permissions(self):
# only team admins and staff members should be able to submit the form
self.check_user_perm(test_factories.create_user(), False)
self.check_user_perm(test_factories.create_user(is_staff=True), True)
for role in (ROLE_ADMIN, ROLE_OWNER):
user = test_factories.create_user()
test_factories.create_team_member(self.team, user, role=role)
self.check_user_perm(user, True)
for role in (ROLE_CONTRIBUTOR, ROLE_MANAGER):
user = test_factories.create_user()
test_factories.create_team_member(self.team, user, role=role)
self.check_user_perm(user, False)
def test_check_authorization_individual(self):
# test check_authorization when linked to a user
tpa = test_factories.create_third_party_account(self.vurl)
tpa.users.add(test_factories.create_user())
# FIXME: should this return True if the user for the ThirdPartyAccount
# doesn't match the user of the video?
self.assertEquals(check_authorization(self.video), (True, True))
def test_subtitle_language_order(self):
# We should display a user's preferred languages first in our language
# list. After that we should list all languages sorted by their label
def language_choices_ordered(*langs_on_top):
choice_map = dict((code, label)
for (code, label) in get_language_choices())
rv = []
for code in langs_on_top:
rv.append((code, choice_map.pop(code)))
rv.extend(sorted(choice_map.items(),
key=lambda choice: choice[1]))
return rv
self.user = test_factories.create_user(languages=['fr', 'es'])
self.assertEquals(
self.make_form()['subtitle_language_code'].field.choices,
language_choices_ordered('fr', 'es'))
# for anonymous users, we should call
# get_user_languages_from_request(). If that fails to return a
# usable result, then we default to english.
self.user = AnonymousUser()
self.mock_get_user_languages_from_request.return_value = ['pt-br']
self.assertEquals(
self.make_form()['subtitle_language_code'].field.choices,
language_choices_ordered('pt-br'))
self.mock_get_user_languages_from_request.return_value = []
self.assertEquals(
self.make_form()['subtitle_language_code'].field.choices,
language_choices_ordered('en'))
def setUp(self):
self.auth = {
"username": u"admin",
"password": u"admin"}
self.user = test_factories.create_user(is_staff=True,
is_superuser=True,
**self.auth)
def test_noop_for_non_team_feed(self):
team = test_factories.create_team()
user = test_factories.create_user()
videos = [test_factories.create_video() for i in xrange(5)]
feed = mock.Mock(team=None, user=user)
feed_imported.send(sender=feed, new_videos=videos)
for video in videos:
self.assertEquals(video.get_team_video(), None)
def test_retrieval(self):
tpa = test_factories.create_third_party_account(self.vurl)
tpa.users.add(test_factories.create_user())
with self.assertRaises(ImproperlyConfigured):
ThirdPartyAccount.objects.always_push_account()
setattr(settings, 'YOUTUBE_ALWAYS_PUSH_USERNAME', tpa.username)
self.assertEquals(ThirdPartyAccount.objects.always_push_account(), tpa)
def test_save_role(self):
owner = self.owner
member_account = test_factories.create_user(username='******',
password='******')
member = test_factories.create_team_member(
self.team, member_account, role=TeamMember.ROLE_CONTRIBUTOR)
tv = self.project_video
video_url = reverse("videos:video", args=(tv.video.video_id,))
owner.user.set_password("hey")
owner.user.save()
self.team.is_visible = False
self.team.save()
resp = self.client.get(video_url, follow=True)
self.assertNotEqual(resp.status_code, 200)
self.team.video_policy = Team.VP_MEMBER
self.task_assign_policy = 10
self.team.save()
self.assertTrue(can_add_video(self.team, member.user))
self.assertTrue(can_add_video_somewhere(self.team, member.user))
self.assertTrue(can_view_tasks_tab(self.team, member.user))
self.assertTrue(can_create_and_edit_subtitles(member.user, tv))
self.assertTrue(can_create_and_edit_translations(member.user, tv))
self.assertFalse(can_view_settings_tab(self.team, member.user))
save_role(self.team, member, ROLE_ADMIN, [], [], owner.user)
member = TeamMember.objects.get(pk=member.pk)
self.assertEqual(member.role, ROLE_ADMIN)
self.assertTrue(can_add_video_somewhere(self.team, member.user))
self.assertTrue(can_view_tasks_tab(self.team, member.user))
self.assertTrue(can_create_and_edit_subtitles(member.user, tv))
self.assertTrue(can_create_and_edit_translations(member.user, tv))
self.assertTrue(can_view_settings_tab(self.team, member.user))
save_role(self.team, member, ROLE_CONTRIBUTOR, [], [], owner.user)
member = TeamMember.objects.get(pk=member.pk)
self.assertEqual(member.role, ROLE_CONTRIBUTOR)
self.assertFalse(can_view_settings_tab(self.team, member.user))
self.assertTrue(can_add_video_somewhere(self.team, member.user))
self.assertTrue(can_view_tasks_tab(self.team, member.user))
self.assertTrue(can_create_and_edit_subtitles(member.user, tv))
self.assertTrue(can_create_and_edit_translations(member.user, tv))
self.client.login(username=member.user.username, password="******")
resp = self.client.get(video_url, follow=True)
self.assertEqual(resp.status_code, 200)
def setUp(self):
self.team = test_factories.create_team(workflow_enabled=True)
self.workflow = test_factories.create_workflow(self.team)
self.user = test_factories.create_user(is_staff=True)
self.member = test_factories.create_team_member(self.team,
self.user,
role=ROLE_ADMIN)
self.video = test_factories.create_video()
self.team_video = test_factories.create_team_video(
self.team, self.user, self.video)
self.non_team_video = test_factories.create_video()
# create a bunch of versions
self.versions = [
pipeline.add_subtitles(self.video, 'en', None) for i in xrange(5)
]
self.language = self.video.get_primary_audio_subtitle_language()
def test_mirror_on_third_party(self):
tpa = test_factories.create_third_party_account(self.vurl)
tpa.users.add(test_factories.create_user())
self.make_language_complete()
lang = self.video.subtitle_language()
version = self.video.subtitle_language().get_tip()
youtube_type_mock = mock.Mock(spec=YoutubeVideoType)
spec = 'videos.types.video_type_registrar.video_type_for_url'
with mock.patch(spec) as video_type_for_url_mock:
video_type_for_url_mock.return_value = youtube_type_mock
ThirdPartyAccount.objects.mirror_on_third_party(
self.video, 'en', UPDATE_VERSION_ACTION, version)
youtube_type_mock.update_subtitles.assert_called_once_with(
version, tpa)
def test_mirror_existing(self):
user = test_factories.create_user()
tpa1 = ThirdPartyAccount.objects.create(username='******')
tpa2 = ThirdPartyAccount.objects.create(username='******')
self.vurl.owner_username = '******'
self.vurl.save()
self.make_language_complete()
user.third_party_accounts.add(tpa1)
user.third_party_accounts.add(tpa2)
data = get_youtube_data(user.pk)
self.assertEquals(1, len(data))
video, language, version = data[0]
self.assertTrue(version.is_public)
self.assertTrue(version.is_synced())
self.assertTrue(language.subtitles_complete)
self.assertTrue(video.get_team_video() is None)
self.assertTrue(can_be_synced(version))
def test_non_ascii_text(self):
non_ascii_text = u'abcd\xe9'
user = test_factories.create_user(username=non_ascii_text)
test_factories.create_team_member(self.team, user)
self.video.title = non_ascii_text
self.video.save()
sv = add_subtitles(self.video, 'en', make_subtitle_lines(4),
title=non_ascii_text,
author=user,
description=non_ascii_text,
complete=True)
video_changed_tasks(self.video.pk, sv.pk)
report = BillingReport.objects.create(
start_date=sv.created - timedelta(days=1),
end_date=sv.created + timedelta(days=1),
type=BillingReport.TYPE_NEW,
)
report.teams.add(self.team)
self.process_report(report)
def setup_users(self):
self.user = User.objects.all()[0]
self.owner_account = test_factories.create_user(username='******')
self.outsider = test_factories.create_user(username='******')
self.site_admin = test_factories.create_user(username='******',
is_staff=True)
def create_member(role):
user = test_factories.create_user(username='******' + role,
password='******' + role)
return TeamMember.objects.create(user=user, role=role, team=team)
def setup_users(self):
self.user = User.objects.all()[0]
self.owner_account = test_factories.create_user(username='******')
self.outsider = test_factories.create_user(username='******')
def setUp(self):
self.video = test_factories.create_video()
self.user_0 = test_factories.create_user()
def setUp(self, MockFeedParserClass):
TestCase.setUp(self)
self.user = test_factories.create_user()
mock_feed_parser = mock.Mock()
mock_feed_parser.version = 1.0
MockFeedParserClass.return_value = mock_feed_parser
def setUp(self, mock_get_user_languages_from_request):
self.video = test_factories.create_video()
self.user = test_factories.create_user()
self.mock_get_user_languages_from_request = \
mock_get_user_languages_from_request
