def test_move_video_allowed(self):
# Check that moving works when the user has permission.
video = test_factories.create_video()
old_team = test_factories.create_team(video_policy=Team.VP_MANAGER)
new_team = test_factories.create_team(video_policy=Team.VP_MANAGER)
team_video = test_factories.create_team_video(old_team, self.user,
video)
# Convenient functions for pulling models fresh from the DB.
get_video = lambda: Video.objects.get(pk=video.pk)
get_team_video = lambda: get_video().get_team_video()
# Create a member that's an admin of BOTH teams.
# This member should be able to move the video.
member = self._create_member(old_team, TeamMember.ROLE_ADMIN)
self._create_member(new_team, TeamMember.ROLE_ADMIN, member.user)
self.assertEqual(get_team_video().team.pk, old_team.pk,
"Video did not start in the correct team.")
# Move the video.
self.client.login(username=member.user.username,
password=member.user.username)
url = reverse("teams:move_video")
response = self.client.post(url, {'team_video': get_team_video().pk,
'team': new_team.pk,})
self.assertEqual(response.status_code, 302)
self.assertEqual(get_team_video().team.pk, new_team.pk,
"Video was not moved to the new team.")
self.assertEqual(get_team_video().project.team, new_team,
"Video ended up with a project for the first team")
def test_move_video_disallowed_new(self):
# Check that moving does not work when the user is blocked by the new
# team.
video = test_factories.create_video()
old_team = test_factories.create_team(video_policy=Team.VP_MANAGER)
new_team = test_factories.create_team(video_policy=Team.VP_MANAGER)
team_video = test_factories.create_team_video(old_team, self.user,
video)
# Convenient functions for pulling models fresh from the DB.
get_video = lambda: Video.objects.get(pk=video.pk)
get_team_video = lambda: get_video().get_team_video()
# Create a member that's a contributor to the new/target team.
# This member should NOT be able to move the video because they cannot
# add it to the second team.
member = self._create_member(old_team, TeamMember.ROLE_ADMIN)
self._create_member(new_team, TeamMember.ROLE_CONTRIBUTOR, member.user)
self.assertEqual(get_team_video().team.pk, old_team.pk,
"Video did not start in the correct team.")
# Try to move the video.
self.client.login(username=member.user.username,
password=member.user.username)
url = reverse("teams:move_video")
response = self.client.post(url, {'team_video': get_team_video().pk,
'team': new_team.pk,})
self.assertEqual(response.status_code, 302)
self.assertEqual(get_team_video().team.pk, old_team.pk,
"Video did not stay in the old team.")
def setUp(self):
TestCase.setUp(self)
self.team = test_factories.create_team()
self.project = Project.objects.create(team=self.team, name='project1')
self.team2 = test_factories.create_team()
self.project2 = Project.objects.create(team=self.team2,
name='project2')
self.video = test_factories.create_video()
self.team_video = test_factories.create_team_video(self.team,
video=self.video)
def setUp(self):
self.team = test_factories.create_team()
self.report = BillingReport.objects.create(
start_date=datetime(2013, 1, 1),
end_date=datetime(2013, 2, 1),
type=BillingReport.TYPE_APPROVAL)
self.report.teams.add(self.team)
def setUp(self):
self.team = test_factories.create_team(workflow_enabled=True)
w = test_factories.create_workflow(self.team, autocreate_subtitle=True)
self.admin = test_factories.create_team_member(
self.team, role=TeamMember.ROLE_ADMIN)
self.client.login(username=self.admin.user.username,
password='******')
def setup_team(self):
self.team = test_factories.create_team(workflow_enabled=True)
test_factories.create_workflow(
self.team,
review_allowed=20, # manager must review
approve_allowed=20, # admin must approve
)
def setUp(self):
self.team = test_factories.create_team(workflow_enabled=True)
w = test_factories.create_workflow(self.team,
autocreate_subtitle=True,
autocreate_translate=True)
self.admin = test_factories.create_team_member(
self.team, role=TeamMember.ROLE_ADMIN)
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 setup_team(self):
self.team = test_factories.create_team(workflow_enabled=True)
workflow = self.team.get_workflow()
workflow.review_allowed = workflow.REVIEW_IDS['Admin must review']
workflow.approve_allowed = workflow.APPROVE_IDS['Admin must approve']
workflow.save()
self.user = test_factories.create_team_member(self.team).user
self.team_video = test_factories.create_team_video(
self.team, self.user, self.video)
def test_check_authorization_team(self):
# test check_authorization when linked to a team
team = test_factories.create_team()
tpa = test_factories.create_third_party_account(self.vurl)
tpa.teams.add(team)
self.assertEquals(check_authorization(self.video), (False, False))
test_factories.create_team_video(team, video=self.video)
self.assertEquals(check_authorization(self.video), (True, True))
def test_user_permissions_check(self):
team = test_factories.create_team(subtitle_policy=40)
test_factories.create_team_video(team=team, video=self.video)
form = self.make_form({
'primary_audio_language_code': 'en',
'subtitle_language_code': 'fr',
})
# The form should be invalid, because our user doesn't have
# permissions to subtitle the video.
self.assertEquals(form.is_valid(), False)
def setUp(self, mock_now):
self.date_maker = DateMaker()
mock_now.side_effect = self.date_maker.next_date
self.team = test_factories.create_team(workflow_enabled=True)
test_factories.create_workflow(
self.team,
review_allowed=0, # no review
approve_allowed=20, # admin must approve
)
self.admin = test_factories.create_team_member(team=self.team,
role=ROLE_ADMIN).user
self.video = test_factories.create_team_video(self.team).video
def setUp(self):
self.team = test_factories.create_team(workflow_enabled=True)
self.workflow = test_factories.create_workflow(
self.team,
review_allowed=DONT_REQUIRE_REVIEW,
approve_allowed=DONT_REQUIRE_APPROVAL)
self.admin = test_factories.create_team_member(
self.team, role=TeamMember.ROLE_ADMIN)
self.team_video = test_factories.create_team_video(
self.team, self.admin.user)
self.client = Client()
self.login(self.admin.user)
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_video_feed_submit(self):
team = test_factories.create_team()
user = test_factories.create_team_member(team).user
self.client.login(username=user.username, password='******')
feed_url = u'http://example.com/feed'
url = reverse('teams:add_videos', kwargs={'slug': team.slug})
data = {
'feed_url': feed_url,
}
response = self.client.post(url, data)
self.assertEqual(team.videos.count(), 2)
for video in team.videos.all():
self.assertEquals(video.user, user)
self.assertEquals(video.get_team_video().added_by, user)
def setUp(self):
TestCase.setUp(self)
self.partner_id = 1234
self.secret = 'Secret'
self.account = KalturaAccount.objects.create(
team=test_factories.create_team(),
partner_id=self.partner_id,
secret=self.secret)
self.entry_id = 'EntryId'
url = ('http://cdnbakmi.kaltura.com'
'/p/1492321/sp/149232100/serveFlavor/entryId/'
'%s/flavorId/1_dqgopb2z/name/video.mp4') % self.entry_id
self.video = test_factories.create_video(url=url, video_type='K')
self.video_url = self.video.get_primary_videourl_obj()
self.version = pipeline.add_subtitles(self.video, 'en',
[(100, 200, "sub 1")])
self.language = self.version.subtitle_language
def test_team_permission(self):
team = test_factories.create_team(slug="private-team",
name="Private Team",
is_visible=False)
TeamMember.objects.create_first_member(team, self.user)
video = test_factories.create_video()
test_factories.create_team_video(team, self.user, video)
url = reverse("videos:video", kwargs={"video_id": video.video_id})
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 404)
self.client.login(**self.auth)
response = self.client.get(url, follow=True)
self.assertEquals(response.status_code, 200)
self.client.logout()
def test_create_team_videos_for_team_feed(self):
api_teamvideo_new_handler = mock.Mock()
api_teamvideo_new.connect(api_teamvideo_new_handler, weak=False)
self.addCleanup(api_teamvideo_new.disconnect,
api_teamvideo_new_handler)
team = test_factories.create_team()
user = test_factories.create_team_member(team).user
videos = [test_factories.create_video() for i in xrange(5)]
feed = mock.Mock(team=team, user=user)
feed_imported.send(sender=feed, new_videos=videos)
for video in videos:
self.assertNotEquals(video.get_team_video(), None)
self.assertEquals(video.get_team_video().team, team)
correct_api_calls = [
mock.call(signal=api_teamvideo_new, sender=video.get_team_video())
for video in videos
]
api_teamvideo_new_handler.assert_has_calls(correct_api_calls,
any_order=True)
def setUp(self):
self.video = test_factories.create_video()
self.team = test_factories.create_team()
self.member = test_factories.create_team_member(self.team)
self.team_video = test_factories.create_team_video(
self.team, self.member.user, self.video)
def test_tasks_not_called_if_no_account(self):
# for non-team videos, we shouldn't schedule a task
video = create_kaltura_video('video2')
other_team = test_factories.create_team()
test_factories.create_team_video(other_team, video=video)
self.check_tasks_not_called(video)
def test_remove_video(self):
team = test_factories.create_team(slug="new-team",
membership_policy=4,
video_policy=1,
name="New-name")
def create_member(role):
user = test_factories.create_user(username='******' + role,
password='******' + role)
return TeamMember.objects.create(user=user, role=role, team=team)
admin = create_member(TeamMember.ROLE_ADMIN)
contributor = create_member(TeamMember.ROLE_CONTRIBUTOR)
manager = create_member(TeamMember.ROLE_MANAGER)
owner = create_member(TeamMember.ROLE_OWNER)
def create_team_video():
return test_factories.create_team_video(team, owner.user)
# The video policy determines who can remove videos from teams.
for member in [contributor, manager, admin, owner]:
self.client.login(username=member.user.username,
password=member.user.username)
tv = create_team_video()
video_url = tv.video.get_video_url()
url = reverse("teams:remove_video", kwargs={"team_video_pk": tv.pk})
response = self.client.post(url)
self.assertEqual(response.status_code, 302)
self.assertFalse(TeamVideo.objects.filter(pk=tv.pk).exists())
self.assertTrue(VideoUrl.objects.get(url=video_url).video)
# Only owners can delete videos entirely.
for role in [owner]:
self.client.login(username=role.user.username,
password=role.user.username)
tv = create_team_video()
video_url = tv.video.get_video_url()
url = reverse("teams:remove_video", kwargs={"team_video_pk": tv.pk})
response = self.client.post(url, {'del-opt': 'total-destruction'})
self.assertEqual(response.status_code, 302)
self.assertFalse(TeamVideo.objects.filter(pk=tv.pk).exists())
self.assertFalse(VideoUrl.objects.filter(url=video_url).exists())
for role in [contributor, manager, admin]:
self.client.login(username=role.user.username,
password=role.user.username)
tv = create_team_video()
video_url = tv.video.get_video_url()
url = reverse("teams:remove_video", kwargs={"team_video_pk": tv.pk})
response = self.client.post(url, {'del-opt': 'total-destruction'})
self.assertEqual(response.status_code, 302)
self.assertTrue(TeamVideo.objects.filter(pk=tv.pk).exists())
self.assertTrue(VideoUrl.objects.filter(url=video_url).exists())
# POST request required
tv = create_team_video()
video_url = tv.video.get_video_url()
url = reverse("teams:remove_video", kwargs={"team_video_pk": tv.pk})
self.client.login(username=self.user.username,
password=self.user.username)
response = self.client.get(url)
self.assertEqual(response.status_code, 302)
self.assertTrue(TeamVideo.objects.filter(pk=tv.pk).exists())
self.assertTrue(VideoUrl.objects.filter(url=video_url).exists())
def setup_team(self):
self.team = test_factories.create_team()
self.owner = test_factories.create_team_member(
self.team, self.owner_account, role=TeamMember.ROLE_OWNER)
self.test_project = test_factories.create_project(self.team)
self.default_project = self.team.default_project
def setUp(self):
self.team = test_factories.create_team()
self.user = test_factories.create_team_member(self.team).user
def setUp(self):
self.team = test_factories.create_team()
