def setUp(self):
self.user = UserFactory()
self.viewset = VideoViewSet()
self.query_params = {}
self.viewset.request = mock.Mock(user=self.user,
query_params=self.query_params)
self.viewset.kwargs = {}
def setUp(self):
# set up a bunch of mock objects so that we can test VideoViewSetTest
# methods.
self.team = TeamFactory()
self.project = ProjectFactory(team=self.team)
self.user = UserFactory()
self.serializer = mock.Mock(validated_data={
'team': self.team,
'project': self.project,
})
self.serializer.will_add_video_to_team.return_value = False
self.serializer.will_remove_video_from_team.return_value = False
self.viewset = VideoViewSet()
self.viewset.request = mock.Mock(user=self.user)
class ViewSetCreateUpdateTestCase(TestCase):
def setUp(self):
# set up a bunch of mock objects so that we can test VideoViewSetTest
# methods.
self.user = UserFactory()
self.team = TeamFactory(admin=self.user)
self.project = ProjectFactory(team=self.team)
self.serializer = mock.Mock(
validated_data={
'team': self.team,
'project': self.project,
},
instance=None,
)
self.serializer.will_add_video_to_team.return_value = False
self.serializer.will_remove_video_from_team.return_value = False
self.viewset = VideoViewSet()
self.viewset.request = mock.Mock(user=self.user)
@test_utils.patch_for_test('teams.permissions.can_add_video')
def test_add_videos_perm_check(self, mock_can_add_video):
# if will_add_video_to_team() returns False, we shouldn't check the
# permission
mock_can_add_video.return_value = True
self.serializer.will_add_video_to_team.return_value = False
self.viewset.check_save_permissions(self.serializer)
assert_equal(mock_can_add_video.call_count, 0)
# if will_add_video_to_team() returns True, we should
self.serializer.will_add_video_to_team.return_value = True
self.viewset.check_save_permissions(self.serializer)
assert_equal(mock_can_add_video.call_count, 1)
assert_equal(mock_can_add_video.call_args,
mock.call(self.team, self.user, self.project))
# test can_add_video returning False
mock_can_add_video.return_value = False
with assert_raises(PermissionDenied):
self.viewset.check_save_permissions(self.serializer)
def test_edit_video_permission_check(self):
team_video = TeamVideoFactory(team=self.team)
self.serializer.instance = team_video.video
with test_utils.patch_get_workflow() as workflow:
workflow.user_can_edit_video.return_value = False
with assert_raises(PermissionDenied):
self.viewset.check_save_permissions(self.serializer)
assert_equal(workflow.user_can_edit_video.call_args,
mock.call(self.user))
@test_utils.patch_for_test('teams.permissions.can_remove_video')
def test_remove_video_perm_check(self, mock_can_remove_video):
team_video = TeamVideoFactory(team=self.team)
self.serializer.instance = team_video.video
mock_can_remove_video.return_value = True
# if will_remove_video_from_team() returns False, we shouldn't check the
# permission
self.serializer.will_remove_video_from_team.return_value = False
self.viewset.check_save_permissions(self.serializer)
assert_equal(mock_can_remove_video.call_count, 0)
# if will_remove_video_from_team() returns True, we should
self.serializer.will_remove_video_from_team.return_value = True
self.viewset.check_save_permissions(self.serializer)
assert_equal(mock_can_remove_video.call_count, 1)
assert_equal(mock_can_remove_video.call_args,
mock.call(team_video, self.user))
# test mock_can_remove_video returning False
mock_can_remove_video.return_value = False
with assert_raises(PermissionDenied):
self.viewset.check_save_permissions(self.serializer)
@test_utils.patch_for_test('videos.tasks.video_changed_tasks')
def test_perform_update_runs_task(self, mock_video_changed_tasks):
video = VideoFactory()
self.serializer.save.return_value = video
self.viewset.perform_update(self.serializer)
assert_equal(mock_video_changed_tasks.delay.call_count, 1)
assert_equal(mock_video_changed_tasks.delay.call_args,
mock.call(video.pk))
class VideoViewSetTest(TestCase):
def setUp(self):
self.user = UserFactory()
self.viewset = VideoViewSet()
self.query_params = {}
self.viewset.request = mock.Mock(user=self.user,
query_params=self.query_params)
self.viewset.kwargs = {}
def test_listing_with_no_filters(self):
# Listing videos without a filter should return the last 20 public videos
public_videos = [
VideoFactory(title='public', is_public=True) for i in range(30)
]
private_videos = [
VideoFactory(title='private', is_public=False) for i in range(30)
]
assert_equal(list(reversed([v.id for v in public_videos[-20:]])),
[v.id for v in self.viewset.get_queryset()])
@test_utils.patch_for_test('subtitles.workflows.get_workflow')
def test_get_detail_checks_workflow_permissions(self, mock_get_workflow):
video = VideoFactory()
workflow = mock.Mock()
workflow.user_can_view_video.return_value = True
mock_get_workflow.return_value = workflow
# test successful permissions check
self.viewset.kwargs['video_id'] = video.video_id
assert_equal(self.viewset.get_object(), video)
# test failed permissions check
workflow.user_can_view_video.return_value = False
with assert_raises(http.Http404):
self.viewset.get_object()
def test_get_detail_returns_403_when_video_not_found(self):
# for non-staff users, if they try to get a video ID that's not in the
# DB, we should return a 403 error. This way they can't use the API
# to query if a team video exists or not.
self.viewset.kwargs['video_id'] = 'bad-video-id'
with assert_raises(PermissionDenied):
self.viewset.get_object()
def test_video_url_filter(self):
v1 = VideoFactory(title='correct video url')
v2 = VideoFactory(title='other video url')
self.query_params['video_url'] = v1.get_video_url()
assert_items_equal([v1], self.viewset.get_queryset())
def test_team_filter(self):
team = TeamFactory(video_visibility=VideoVisibility.PUBLIC)
v1 = VideoFactory(title='correct team')
v2 = VideoFactory(title='wrong team')
v3 = VideoFactory(title='not in team')
TeamVideoFactory(team=team, video=v1)
TeamVideoFactory(video=v2)
self.query_params['team'] = team.slug
assert_items_equal([v1], self.viewset.get_queryset())
def test_project_filter(self):
team = TeamFactory(video_visibility=VideoVisibility.PUBLIC)
project = ProjectFactory(team=team, slug='project')
other_project = ProjectFactory(team=team, slug='wrong-project')
v1 = VideoFactory(title='correct project')
v2 = VideoFactory(title='wrong project')
v3 = VideoFactory(title='default project')
v4 = VideoFactory(title='no team')
TeamVideoFactory(video=v1, team=team, project=project)
TeamVideoFactory(video=v2, team=team, project=other_project)
TeamVideoFactory(video=v3, team=team)
self.query_params['team'] = team.slug
self.query_params['project'] = project.slug
assert_items_equal([v1], self.viewset.get_queryset())
def test_default_project_filter(self):
team = TeamFactory(video_visibility=VideoVisibility.PUBLIC)
project = ProjectFactory(team=team, slug='project-slug')
v1 = VideoFactory(title='in default project')
v2 = VideoFactory(title='not in default project')
TeamVideoFactory(video=v1, team=team)
TeamVideoFactory(video=v2, team=team, project=project)
self.query_params['team'] = team.slug
self.query_params['project'] = 'null'
assert_items_equal([v1], self.viewset.get_queryset())
def test_team_filter_user_is_not_member(self):
team = TeamFactory()
video = TeamVideoFactory(team=team).video
self.query_params['team'] = team.slug
assert_items_equal([], self.viewset.get_queryset())
