def test_extract_videos_topics(mocker, use_video_ids):
"""Tests that extract_videos_topics yields objects for each video with topics"""
published_videos = VideoFactory.create_batch(3, published=True)
# shouldn't be extracted
VideoFactory.create_batch(3, published=False)
topic_results = [[f"topic-{idx}-a", f"topic-{idx}-b"]
for idx in range(len(published_videos))]
mock_get_similar_topics = mocker.patch(
"course_catalog.etl.video.get_similar_topics",
side_effect=topic_results)
if use_video_ids:
published_videos = published_videos[:1]
result = list(
extract_videos_topics(
video_ids=[published_videos[0].id] if use_video_ids else None))
assert len(result) == len(published_videos)
for video, topics in zip(published_videos, topic_results):
assert {
"video_id": video.video_id,
"platform": video.platform,
"topics": [{
"name": topic
} for topic in topics],
} in result
assert mock_get_similar_topics.call_count == (1 if use_video_ids else
len(published_videos))
def test_serialize_bulk_video(mocker):
"""
Test that serialize_bulk_video calls serialize_video_for_bulk for every existing video
"""
mock_serialize_video = mocker.patch("search.serializers.serialize_video_for_bulk")
videos = VideoFactory.create_batch(5)
list(serialize_bulk_videos(Video.objects.values_list("id", flat=True)))
for video in videos:
mock_serialize_video.assert_any_call(video)
def test_popular_content_types(client, user, mocker):
"""Test the popular content types API"""
# create 2 of each, generate interactions for only the first one
# second one shouldn't show up in the results
course = CourseFactory.create_batch(2)[0]
bootcamp = BootcampFactory.create_batch(2)[0]
program = ProgramFactory.create_batch(2)[0]
user_list = UserListFactory.create_batch(2)[0]
video = VideoFactory.create_batch(2)[0]
# generate interactions with an increasing count
interactions = [
ContentTypeInteractionFactory.create_batch(count + 1,
content=content)[0]
for count, content in enumerate(
[user_list, bootcamp, video, course, program])
]
response = client.get(reverse("popular_content-list"))
# the response should be ordered such that items with a higher count of interactions are first
# this ends up being the reverse order of `interactions` since we used `enumerate()`
assert response.json() == {
"results":
PopularContentSerializer(
[{
"content_type_id": interaction.content_type_id,
"content_id": interaction.content_id,
} for interaction in reversed(interactions)],
many=True,
context={
"request": mocker.Mock(user=user)
},
).data,
"next":
None,
"previous":
None,
"count":
len(interactions),
}
def test_load_playlist_user_list(mock_upsert_tasks, settings, user, exists,
has_user_list, user_list_title):
# pylint: disable=too-many-arguments
"""Test that load_playlist_user_list updates or create the user list"""
settings.OPEN_VIDEO_USER_LIST_OWNER = user.username
playlist = PlaylistFactory.create(has_user_list=has_user_list)
videos = VideoFactory.create_batch(3)
for idx, video in enumerate(videos):
PlaylistVideo.objects.create(playlist=playlist,
video=video,
position=idx)
prune_video = VideoFactory.create()
video_content_type = ContentType.objects.get_for_model(Video)
user_list = None
if exists:
user_list = UserListFactory.create(is_list=True,
is_public=True,
author=user)
UserListItem.objects.create(
user_list=user_list,
content_type=video_content_type,
object_id=prune_video.id,
position=0,
)
playlist.user_list = user_list
playlist.save()
else:
assert playlist.user_list is None
load_playlist_user_list(playlist, user_list_title)
playlist.refresh_from_db()
if has_user_list:
if exists:
assert playlist.user_list == user_list
else:
assert playlist.user_list is not None
user_list = playlist.user_list
assert user_list.author == user
if user_list_title:
assert user_list.title == user_list_title
else:
assert user_list.title == playlist.title
assert user_list.privacy_level == PrivacyLevel.public.value
assert user_list.list_type == ListType.LIST.value
assert (UserListItem.objects.filter(
user_list=user_list,
content_type=video_content_type,
object_id=prune_video.id,
).exists() is False)
for video in videos:
assert (UserListItem.objects.filter(
user_list=user_list,
content_type=video_content_type,
object_id=video.id,
).exists() is True)
mock_upsert_tasks.upsert_user_list.assert_called_once_with(
user_list.id)
else:
assert playlist.user_list is None
if exists:
mock_upsert_tasks.delete_user_list.assert_called_once_with(
user_list)
else:
mock_upsert_tasks.delete_user_list.assert_not_called()