def test_es_userlist_serializer_image_src():
"""
Test that ESUserListSerializer uses 1st non-list list item image_src if the list image_src is None
"""
user_list = UserListFactory.create(image_src=None)
UserListItemFactory.create(user_list=user_list, position=1, is_userlist=True)
list_item_course = UserListItemFactory.create(
user_list=user_list, position=2, is_course=True
)
serialized = ESUserListSerializer(user_list).data
assert_json_equal(
serialized,
{
"author": user_list.author.id,
"object_type": user_list.list_type,
"list_type": user_list.list_type,
"privacy_level": user_list.privacy_level,
"id": user_list.id,
"short_description": user_list.short_description,
"title": user_list.title,
"image_src": list_item_course.item.image_src,
"topics": list(user_list.topics.values_list("name", flat=True)),
"created": drf_datetime(user_list.created_on),
"default_search_priority": 0,
"minimum_price": 0,
},
)
def test_user_list_items_endpoint_update_item(client, user, is_author,
mock_user_list_index):
"""Test userlistitems endpoint for updating UserListItem positions"""
author = UserFactory.create()
topics = CourseTopicFactory.create_batch(3)
userlist = UserListFactory.create(author=author,
privacy_level=PrivacyLevel.public.value,
topics=topics)
list_item_1 = UserListItemFactory.create(user_list=userlist, position=0)
list_item_2 = UserListItemFactory.create(user_list=userlist, position=1)
list_item_3 = UserListItemFactory.create(user_list=userlist, position=2)
client.force_login(author if is_author else user)
data = {"position": 0}
resp = client.patch(
reverse("userlistitems-detail", args=[userlist.id, list_item_3.id]),
data=data,
format="json",
)
assert resp.status_code == (200 if is_author else 403)
if resp.status_code == 200:
assert resp.json()["position"] == 0
mock_user_list_index.upsert_user_list.assert_called_once_with(
userlist.id)
for idx, item in enumerate([list_item_3, list_item_1, list_item_2]):
item.refresh_from_db()
assert item.position == idx
def test_user_list_endpoint_get(client, is_public, is_author, user):
"""Test learning path endpoint"""
author = UserFactory.create()
user_list = UserListFactory.create(
author=author,
privacy_level=PrivacyLevel.public.value
if is_public else PrivacyLevel.private.value,
)
another_user_list = UserListFactory.create(
author=UserFactory.create(),
privacy_level=PrivacyLevel.public.value
if is_public else PrivacyLevel.private.value,
)
UserListItemFactory.create(user_list=user_list,
position=1,
is_bootcamp=True)
UserListItemFactory.create(user_list=user_list, position=2)
# Anonymous users should get no results
resp = client.get(reverse("userlists-list"))
assert resp.data.get("count") == 0
# Logged in user should get own lists
client.force_login(author if is_author else user)
resp = client.get(reverse("userlists-list"))
assert resp.data.get("count") == (1 if is_author else 0)
if is_author:
assert "content_data" not in resp.data.get("results")[0]
resp = client.get(reverse("userlists-detail", args=[user_list.id]))
assert resp.status_code == (403 if not (is_public or is_author) else 200)
if resp.status_code == 200:
assert resp.data.get("title") == user_list.title
assert len(resp.data.get("lists")) == 0
assert resp.data.get("item_count") == 2
# Logged in user should see other person's public list
resp = client.get(reverse("userlists-detail", args=[another_user_list.id]))
assert resp.status_code == (403 if not is_public else 200)
if resp.status_code == 200:
assert resp.data.get("title") == another_user_list.title
def test_cascade_delete_listitems(kwargs):
"""
When a resource is deleted, UserListItems for that resource should be deleted
"""
user_list = UserListFactory.create()
list_item = UserListItemFactory.create(user_list=user_list, **kwargs)
assert user_list.items.count() == 1
resource = list_item.item
resource.delete()
assert user_list.items.count() == 0
def test_user_list_endpoint_patch(client, user, mock_user_list_index,
update_topics):
"""Test userlist endpoint for updating a UserList"""
[original_topic, new_topic] = CourseTopicFactory.create_batch(2)
userlist = UserListFactory.create(author=user,
title="Title 1",
topics=[original_topic])
UserListItemFactory.create(user_list=userlist)
client.force_login(user)
data = {"title": "Title 2"}
if update_topics:
data["topics"] = [new_topic.id]
resp = client.patch(reverse("userlists-detail", args=[userlist.id]),
data=data,
format="json")
assert resp.status_code == 200
assert UserList.objects.get(id=userlist.id).title == "Title 2"
assert resp.data["topics"][0]["id"] == (new_topic.id if update_topics else
original_topic.id)
mock_user_list_index.upsert_user_list.assert_called_once_with(userlist.id)
def test_bootcamp_detail_endpoint_lists(user_client, user):
"""Test that author's list ids are included"""
bootcamp = BootcampFactory.create()
user_lists = UserListFactory.create_batch(2, author=user)
list_items = sorted(
[
UserListItemFactory.create(content_object=bootcamp,
user_list=user_list)
for user_list in user_lists
],
key=lambda x: x.id,
)
resp = user_client.get(reverse("bootcamps-detail", args=[bootcamp.id]))
assert sorted(resp.data.get("lists"), key=lambda x: x["item_id"]) == [
MicroUserListItemSerializer(list_item).data for list_item in list_items
]
def test_user_list_items_endpoint_update_items_wrong_list(client, user):
"""Verify that trying an update via userlistitems api in wrong list fails"""
userlist = UserListFactory.create(author=user,
privacy_level=PrivacyLevel.public.value)
list_item_incorrect = UserListItemFactory.create()
client.force_login(user)
data = {"id": list_item_incorrect.id, "position": 44}
resp = client.patch(
reverse("userlistitems-detail",
args=[userlist.id, list_item_incorrect.id]),
data=data,
format="json",
)
assert resp.status_code == 404
def test_userlistitems_object_permissions(mocker, user, is_public, is_author,
is_safe):
"""
HasUserListItemPermissions.has_object_permission should return correct permission depending
on privacy level, author, and request method.
"""
userlist = UserListFactory.create(
author=user,
privacy_level=PrivacyLevel.public.value
if is_public else PrivacyLevel.private.value,
)
userlist_item = UserListItemFactory.create(user_list=userlist)
request = mocker.MagicMock(
method="GET" if is_safe else "POST",
user=(user if is_author else UserFactory.create()),
)
view = mocker.MagicMock(kwargs={"parent_lookup_user_list_id": userlist.id})
assert HasUserListItemPermissions().has_object_permission(
request, view, userlist_item) is (is_author or (is_safe and is_public))