def test_load_topics(parent_factory, topics_exist):
"""Test that load_topics creates and/or assigns topics to the parent object"""
topics = (CourseTopicFactory.create_batch(3)
if topics_exist else CourseTopicFactory.build_batch(3))
parent = parent_factory.create(no_topics=True)
assert parent.topics.count() == 0
load_topics(parent, [{"name": topic.name} for topic in topics])
assert parent.topics.count() == len(topics)
def test_favorites_serializer():
"""
Test that the favorite serializer generic foreign key works and also rejects unexpected classes
"""
user = UserFactory.create()
course = CourseFactory.create()
bootcamp = BootcampFactory.create()
user_list = UserListFactory.create(author=user)
program = ProgramFactory.create()
course_topic = CourseTopicFactory.create()
favorite_item = FavoriteItem(user=user, item=course)
serializer = FavoriteItemSerializer(favorite_item)
assert serializer.data.get("content_data") == CourseSerializer(course).data
favorite_item = FavoriteItem(user=user, item=bootcamp)
serializer = FavoriteItemSerializer(favorite_item)
assert serializer.data.get("content_data") == BootcampSerializer(
bootcamp).data
favorite_item = FavoriteItem(user=user, item=user_list)
serializer = FavoriteItemSerializer(favorite_item)
assert serializer.data.get("content_data") == UserListSerializer(
user_list).data
favorite_item = FavoriteItem(user=user, item=program)
serializer = FavoriteItemSerializer(favorite_item)
assert serializer.data.get("content_data") == ProgramSerializer(
program).data
favorite_item = FavoriteItem(user=user, item=course_topic)
serializer = FavoriteItemSerializer(favorite_item)
with pytest.raises(Exception):
assert serializer.data.get("content_data").get("id") == course_topic.id
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_topic_endpoint(client):
"""Test topic endpoint"""
topics = CourseTopicFactory.create_batch(5)
resp = client.get(reverse("topics-list"))
assert resp.data.get("count") == 5
topic = topics[0]
resp = client.get(reverse("topics-detail", args=[topic.id]))
assert resp.data == CourseTopicSerializer(topic).data
def test_serialize_bootcamp_related_models():
"""
Verify that a serialized bootcamp contains attributes for related objects
"""
bootcamp = BootcampFactory.create(
topics=CourseTopicFactory.create_batch(3))
serializer = BootcampSerializer(bootcamp)
assert len(serializer.data["topics"]) == 3
assert "name" in serializer.data["topics"][0].keys()
assert len(serializer.data["runs"]) == 3
def test_serialize_course_related_models(offered_by):
"""
Verify that a serialized course contains attributes for related objects
"""
course = CourseFactory(offered_by=offered_by,
topics=CourseTopicFactory.create_batch(3))
serializer = CourseSerializer(course)
assert len(serializer.data["topics"]) == 3
assert "name" in serializer.data["topics"][0].keys()
assert len(serializer.data["runs"]) == 3
def test_serialize_program_related_models():
"""
Verify that a serialized program contains attributes for related objects
"""
program = ProgramFactory.create(topics=CourseTopicFactory.create_batch(3))
ProgramItemCourseFactory.create_batch(4, program=program)
serializer = ProgramSerializer(program)
assert len(serializer.data["topics"]) == 3
assert len(serializer.data["runs"]) == 1
assert len(serializer.data["items"]) == 4
assert "content_data" in serializer.data["items"][0].keys()
def test_userlist_serializer_validation(list_type, valid):
"""
Test that the UserListSerializer validates list_type and topics correctly
"""
topics = CourseTopicFactory.create_batch(2)
data = {
"title": "My List",
"list_type": list_type,
"topics": [topic.id for topic in topics],
}
serializer = UserListSerializer(data=data)
assert serializer.is_valid() is valid
data["topics"] = CourseTopicSerializer(instance=topics, many=True).data
serializer = UserListSerializer(data=data)
assert serializer.is_valid() is valid
def test_serialize_course_related_models():
"""
Verify that a serialized course contains attributes for related objects
"""
course = CourseFactory(
topics=CourseTopicFactory.create_batch(3),
prices=CoursePriceFactory.create_batch(2),
instructors=CourseInstructorFactory.create_batch(2),
)
serializer = CourseSerializer(course)
assert len(serializer.data["prices"]) == 2
for attr in ("mode", "price"):
assert attr in serializer.data["prices"][0].keys()
assert len(serializer.data["instructors"]) == 2
for attr in ("first_name", "last_name"):
assert attr in serializer.data["instructors"][0].keys()
assert len(serializer.data["topics"]) == 3
assert "name" in serializer.data["topics"][0].keys()
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)