3116 lines
126 KiB
Python
3116 lines
126 KiB
Python
"""
|
||
Tests for the teams API at the HTTP request level.
|
||
"""
|
||
|
||
|
||
import json
|
||
import unittest
|
||
from datetime import datetime
|
||
from unittest.mock import patch
|
||
from uuid import UUID
|
||
|
||
import ddt
|
||
import pytz
|
||
from dateutil import parser
|
||
from django.conf import settings
|
||
from django.core.files.uploadedfile import SimpleUploadedFile
|
||
from django.db.models.signals import post_save
|
||
from django.urls import reverse
|
||
from django.utils import translation
|
||
from elasticsearch.exceptions import ConnectionError # lint-amnesty, pylint: disable=redefined-builtin
|
||
from rest_framework.test import APIClient, APITestCase
|
||
from search.search_engine_base import SearchEngine
|
||
|
||
from common.djangoapps.course_modes.models import CourseMode
|
||
from common.djangoapps.student.models import CourseEnrollment
|
||
from common.djangoapps.student.tests.factories import AdminFactory, CourseEnrollmentFactory, UserFactory
|
||
from common.djangoapps.util.testing import EventTestMixin
|
||
from common.test.utils import skip_signal
|
||
from lms.djangoapps.courseware.tests.factories import StaffFactory
|
||
from lms.djangoapps.program_enrollments.tests.factories import ProgramEnrollmentFactory
|
||
from openedx.core.djangoapps.django_comment_common.models import FORUM_ROLE_COMMUNITY_TA, Role
|
||
from openedx.core.djangoapps.django_comment_common.utils import seed_permissions_roles
|
||
from openedx.core.lib.teams_config import TeamsConfig
|
||
from xmodule.modulestore.tests.django_utils import SharedModuleStoreTestCase
|
||
from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
|
||
|
||
from ..models import CourseTeamMembership
|
||
from ..search_indexes import CourseTeam, CourseTeamIndexer, course_team_post_save_callback
|
||
from .factories import LAST_ACTIVITY_AT, CourseTeamFactory
|
||
|
||
|
||
@ddt.ddt
|
||
class TestDashboard(SharedModuleStoreTestCase):
|
||
"""Tests for the Teams dashboard."""
|
||
test_password = "test"
|
||
|
||
NUM_TOPICS = 10
|
||
|
||
@classmethod
|
||
def setUpClass(cls):
|
||
super().setUpClass()
|
||
cls.course = CourseFactory.create(
|
||
teams_configuration=TeamsConfig({
|
||
"max_team_size": 10,
|
||
"topics": [
|
||
{
|
||
"name": f"Topic {topic_id}",
|
||
"id": topic_id,
|
||
"description": f"Description for topic {topic_id}"
|
||
}
|
||
for topic_id in range(cls.NUM_TOPICS)
|
||
]
|
||
})
|
||
)
|
||
|
||
def setUp(self):
|
||
"""
|
||
Set up tests
|
||
"""
|
||
super().setUp()
|
||
# will be assigned to self.client by default
|
||
self.user = UserFactory.create(password=self.test_password)
|
||
self.teams_url = reverse('teams_dashboard', args=[self.course.id])
|
||
|
||
def test_anonymous(self):
|
||
"""Verifies that an anonymous client cannot access the team
|
||
dashboard, and is redirected to the login page."""
|
||
anonymous_client = APIClient()
|
||
response = anonymous_client.get(self.teams_url)
|
||
redirect_url = f'{settings.LOGIN_URL}?next={self.teams_url}'
|
||
self.assertRedirects(response, redirect_url)
|
||
|
||
def test_not_enrolled_not_staff(self):
|
||
""" Verifies that a student who is not enrolled cannot access the team dashboard. """
|
||
self.client.login(username=self.user.username, password=self.test_password)
|
||
response = self.client.get(self.teams_url)
|
||
assert 404 == response.status_code
|
||
|
||
def test_not_enrolled_staff(self):
|
||
"""
|
||
Verifies that a user with global access who is not enrolled in the course can access the team dashboard.
|
||
"""
|
||
staff_user = UserFactory(is_staff=True, password=self.test_password)
|
||
staff_client = APIClient()
|
||
staff_client.login(username=staff_user.username, password=self.test_password)
|
||
response = staff_client.get(self.teams_url)
|
||
self.assertContains(response, "TeamsTabFactory", status_code=200)
|
||
|
||
def test_enrolled_not_staff(self):
|
||
"""
|
||
Verifies that a user without global access who is enrolled in the course can access the team dashboard.
|
||
"""
|
||
CourseEnrollmentFactory.create(user=self.user, course_id=self.course.id)
|
||
self.client.login(username=self.user.username, password=self.test_password)
|
||
response = self.client.get(self.teams_url)
|
||
self.assertContains(response, "TeamsTabFactory", status_code=200)
|
||
|
||
def test_enrolled_teams_not_enabled(self):
|
||
"""
|
||
Verifies that a user without global access who is enrolled in the course cannot access the team dashboard
|
||
if the teams feature is not enabled.
|
||
"""
|
||
course = CourseFactory.create()
|
||
teams_url = reverse('teams_dashboard', args=[course.id])
|
||
CourseEnrollmentFactory.create(user=self.user, course_id=course.id)
|
||
self.client.login(username=self.user.username, password=self.test_password)
|
||
response = self.client.get(teams_url)
|
||
assert 404 == response.status_code
|
||
|
||
@unittest.skip("Fix this - getting unreliable query counts")
|
||
def test_query_counts(self):
|
||
# Enroll in the course and log in
|
||
CourseEnrollmentFactory.create(user=self.user, course_id=self.course.id)
|
||
self.client.login(username=self.user.username, password=self.test_password)
|
||
|
||
# Check the query count on the dashboard with no teams
|
||
with self.assertNumQueries(18):
|
||
self.client.get(self.teams_url)
|
||
|
||
# Create some teams
|
||
for topic_id in range(self.NUM_TOPICS):
|
||
team = CourseTeamFactory.create(
|
||
name=f"Team for topic {topic_id}",
|
||
course_id=self.course.id,
|
||
topic_id=topic_id,
|
||
)
|
||
|
||
# Add the user to the last team
|
||
team.add_user(self.user)
|
||
|
||
# Check the query count on the dashboard again
|
||
with self.assertNumQueries(24):
|
||
self.client.get(self.teams_url)
|
||
|
||
def test_bad_course_id(self):
|
||
"""
|
||
Verifies expected behavior when course_id does not reference an existing course or is invalid.
|
||
"""
|
||
bad_org = "badorgxxx"
|
||
bad_team_url = self.teams_url.replace(self.course.id.org, bad_org)
|
||
CourseEnrollmentFactory.create(user=self.user, course_id=self.course.id)
|
||
self.client.login(username=self.user.username, password=self.test_password)
|
||
response = self.client.get(bad_team_url)
|
||
assert 404 == response.status_code
|
||
|
||
bad_team_url = bad_team_url.replace(bad_org, "invalid/course/id")
|
||
response = self.client.get(bad_team_url)
|
||
assert 404 == response.status_code
|
||
|
||
def get_user_course_specific_teams_list(self):
|
||
"""Gets the list of user course specific teams."""
|
||
|
||
# Create a course two
|
||
course_two = CourseFactory.create(
|
||
teams_configuration=TeamsConfig({
|
||
"max_team_size": 1,
|
||
"topics": [
|
||
{
|
||
"name": "Test topic for course two",
|
||
"id": 1,
|
||
"description": "Description for test topic for course two."
|
||
}
|
||
]
|
||
})
|
||
)
|
||
|
||
# Login and enroll user in both course course
|
||
self.client.login(username=self.user.username, password=self.test_password)
|
||
CourseEnrollmentFactory.create(user=self.user, course_id=self.course.id)
|
||
CourseEnrollmentFactory.create(user=self.user, course_id=course_two.id)
|
||
|
||
# Create teams in both courses
|
||
course_one_team = CourseTeamFactory.create(name="Course one team", course_id=self.course.id, topic_id=1)
|
||
course_two_team = CourseTeamFactory.create(name="Course two team", course_id=course_two.id, topic_id=1) # pylint: disable=unused-variable
|
||
|
||
# Check that initially list of user teams in course one is empty
|
||
course_one_teams_url = reverse('teams_dashboard', args=[self.course.id])
|
||
response = self.client.get(course_one_teams_url)
|
||
self.assertContains(response, '"teams": {"count": 0')
|
||
# Add user to a course one team
|
||
course_one_team.add_user(self.user)
|
||
|
||
# Check that list of user teams in course one is not empty, it is one now
|
||
response = self.client.get(course_one_teams_url)
|
||
self.assertContains(response, '"teams": {"count": 1')
|
||
# Check that list of user teams in course two is still empty
|
||
course_two_teams_url = reverse('teams_dashboard', args=[course_two.id])
|
||
response = self.client.get(course_two_teams_url)
|
||
self.assertContains(response, '"teams": {"count": 0')
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
(True, False, False),
|
||
(False, True, False),
|
||
(False, False, True),
|
||
(True, True, True),
|
||
(False, True, True),
|
||
)
|
||
def test_teamset_counts(self, has_open, has_private, has_public):
|
||
topics = []
|
||
if has_open:
|
||
topics.append({
|
||
"name": "test topic 1",
|
||
"id": 1,
|
||
"description": "Desc1",
|
||
"type": "open"
|
||
})
|
||
if has_private:
|
||
topics.append({
|
||
"name": "test topic 2",
|
||
"id": 2,
|
||
"description": "Desc2",
|
||
"type": "private_managed"
|
||
})
|
||
if has_public:
|
||
topics.append({
|
||
"name": "test topic 3",
|
||
"id": 3,
|
||
"description": "Desc3",
|
||
"type": "public_managed"
|
||
})
|
||
|
||
course = CourseFactory.create(
|
||
teams_configuration=TeamsConfig({"topics": topics})
|
||
)
|
||
teams_url = reverse('teams_dashboard', args=[course.id])
|
||
CourseEnrollmentFactory.create(user=self.user, course_id=course.id)
|
||
self.client.login(username=self.user.username, password=self.test_password)
|
||
response = self.client.get(teams_url)
|
||
|
||
expected_has_open = "hasOpenTopic: " + "true" if has_open else "false"
|
||
expected_has_public = "hasPublicManagedTopic: " + "true" if has_public else "false"
|
||
|
||
self.assertContains(response, expected_has_open)
|
||
self.assertContains(response, expected_has_public)
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
(True, False, False),
|
||
(False, True, False),
|
||
(False, False, True),
|
||
(True, True, True),
|
||
(False, True, True),
|
||
)
|
||
def test_has_managed_topic(self, has_open, has_private, has_public):
|
||
topics = []
|
||
if has_open:
|
||
topics.append({
|
||
"name": "test topic 1",
|
||
"id": 1,
|
||
"description": "Desc1",
|
||
"type": "open"
|
||
})
|
||
if has_private:
|
||
topics.append({
|
||
"name": "test topic 2",
|
||
"id": 2,
|
||
"description": "Desc2",
|
||
"type": "private_managed"
|
||
})
|
||
if has_public:
|
||
topics.append({
|
||
"name": "test topic 3",
|
||
"id": 3,
|
||
"description": "Desc3",
|
||
"type": "public_managed"
|
||
})
|
||
|
||
# Given a staff user browsing the teams tab
|
||
course = CourseFactory.create(
|
||
teams_configuration=TeamsConfig({"topics": topics})
|
||
)
|
||
teams_url = reverse('teams_dashboard', args=[course.id])
|
||
|
||
staff_user = UserFactory(is_staff=True, password=self.test_password)
|
||
staff_client = APIClient()
|
||
staff_client.login(username=staff_user.username, password=self.test_password)
|
||
|
||
# When I browse to the team tab
|
||
response = staff_client.get(teams_url)
|
||
|
||
# Then "hasManagedTopic" (which is used to show the "Manage" tab)
|
||
# is shown if there are managed team-sets
|
||
expected_has_managed = "hasManagedTopic: " + "true" if has_public or has_private else "false"
|
||
self.assertContains(response, expected_has_managed)
|
||
|
||
|
||
class TeamAPITestCase(APITestCase, SharedModuleStoreTestCase):
|
||
"""Base class for Team API test cases."""
|
||
|
||
test_password = 'password'
|
||
|
||
@classmethod
|
||
def setUpClass(cls):
|
||
# pylint: disable=super-method-not-called
|
||
with super().setUpClassAndTestData():
|
||
base_topics = [{
|
||
'id': f'topic_{i}', 'name': name,
|
||
'description': f'Description for topic {i}.',
|
||
'max_team_size': 3
|
||
} for i, name in enumerate(['Sólar power', 'Wind Power', 'Nuclear Power', 'Coal Power'])]
|
||
base_topics.append(
|
||
{
|
||
'id': 'private_topic_1_id',
|
||
'name': 'private_topic_1_name',
|
||
'description': 'Description for topic private topic 1.',
|
||
'type': 'private_managed'
|
||
}
|
||
)
|
||
base_topics.append(
|
||
{
|
||
'id': 'private_topic_2_id',
|
||
'name': 'private_topic_2_name',
|
||
'description': 'Description for topic private topic 2.',
|
||
'type': 'private_managed'
|
||
}
|
||
)
|
||
base_topics.append(
|
||
{
|
||
'id': 'private_topic_no_teams',
|
||
'name': 'private_topic_no_teams_name',
|
||
'description': 'Description for topic private_topic_no_teams.',
|
||
'type': 'private_managed'
|
||
}
|
||
)
|
||
teams_configuration_1 = TeamsConfig({
|
||
'topics': base_topics,
|
||
'max_team_size': 5
|
||
})
|
||
|
||
cls.test_course_1 = CourseFactory.create(
|
||
org='TestX',
|
||
course='TS101',
|
||
display_name='Test Course',
|
||
teams_configuration=teams_configuration_1
|
||
)
|
||
|
||
teams_configuration_2 = TeamsConfig({
|
||
'topics':
|
||
[
|
||
{
|
||
'id': 'topic_5',
|
||
'name': 'Other Interests',
|
||
'description': 'Description for topic 5.'
|
||
},
|
||
{
|
||
'id': 'topic_6',
|
||
'name': 'Public Profiles',
|
||
'description': 'Description for topic 6.'
|
||
},
|
||
{
|
||
'id': 'Topic_6.5',
|
||
'name': 'Test Accessibility Topic',
|
||
'description': 'Description for Topic_6.5'
|
||
},
|
||
],
|
||
'max_team_size': 1
|
||
})
|
||
cls.test_course_2 = CourseFactory.create(
|
||
org='MIT',
|
||
course='6.002x',
|
||
display_name='Circuits',
|
||
teams_configuration=teams_configuration_2
|
||
)
|
||
|
||
@classmethod
|
||
def setUpTestData(cls):
|
||
super().setUpTestData()
|
||
cls.topics_count = 6
|
||
cls.users = {
|
||
'staff': AdminFactory.create(password=cls.test_password),
|
||
'course_staff': StaffFactory.create(course_key=cls.test_course_1.id, password=cls.test_password),
|
||
'admin': AdminFactory.create(password=cls.test_password)
|
||
}
|
||
cls.create_and_enroll_student(username='student_enrolled')
|
||
cls.create_and_enroll_student(username='student_on_team_1_private_set_1', mode=CourseMode.MASTERS)
|
||
cls.create_and_enroll_student(username='student_on_team_2_private_set_1', mode=CourseMode.MASTERS)
|
||
cls.create_and_enroll_student(username='student_not_member_of_private_teams', mode=CourseMode.MASTERS)
|
||
cls.create_and_enroll_student(username='student_enrolled_not_on_team')
|
||
cls.create_and_enroll_student(username='student_unenrolled', courses=[])
|
||
|
||
# Make this student a community TA.
|
||
cls.create_and_enroll_student(username='community_ta')
|
||
seed_permissions_roles(cls.test_course_1.id)
|
||
community_ta_role = Role.objects.get(name=FORUM_ROLE_COMMUNITY_TA, course_id=cls.test_course_1.id)
|
||
community_ta_role.users.add(cls.users['community_ta'])
|
||
|
||
# This student is enrolled in both test courses and is a member of a team in each course, but is not on the
|
||
# same team as student_enrolled.
|
||
cls.create_and_enroll_student(
|
||
courses=[cls.test_course_1, cls.test_course_2],
|
||
username='student_enrolled_both_courses_other_team'
|
||
)
|
||
|
||
# Make this student have a public profile
|
||
cls.create_and_enroll_student(
|
||
courses=[cls.test_course_2],
|
||
username='student_enrolled_public_profile'
|
||
)
|
||
profile = cls.users['student_enrolled_public_profile'].profile
|
||
profile.year_of_birth = 1970
|
||
profile.save()
|
||
|
||
# This student is enrolled in the other course, but not yet a member of a team. This is to allow
|
||
# course_2 to use a max_team_size of 1 without breaking other tests on course_1
|
||
cls.create_and_enroll_student(
|
||
courses=[cls.test_course_2],
|
||
username='student_enrolled_other_course_not_on_team'
|
||
)
|
||
|
||
# This is a Masters student who should be in the organization protected bubble
|
||
cls.create_and_enroll_student(
|
||
courses=[cls.test_course_1, cls.test_course_2],
|
||
username='student_masters',
|
||
mode=CourseMode.MASTERS
|
||
)
|
||
cls.create_and_enroll_student(
|
||
courses=[cls.test_course_1, cls.test_course_2],
|
||
username='student_masters_not_on_team',
|
||
mode=CourseMode.MASTERS
|
||
)
|
||
|
||
with skip_signal(
|
||
post_save,
|
||
receiver=course_team_post_save_callback,
|
||
sender=CourseTeam,
|
||
dispatch_uid='teams.signals.course_team_post_save_callback'
|
||
):
|
||
cls.solar_team = CourseTeamFactory.create(
|
||
name='Sólar team',
|
||
course_id=cls.test_course_1.id,
|
||
topic_id='topic_0'
|
||
)
|
||
cls.wind_team = CourseTeamFactory.create(
|
||
name='Wind Team',
|
||
course_id=cls.test_course_1.id,
|
||
topic_id='topic_1'
|
||
)
|
||
cls.nuclear_team = CourseTeamFactory.create(
|
||
name='Nuclear Team',
|
||
course_id=cls.test_course_1.id,
|
||
topic_id='topic_2'
|
||
)
|
||
cls.another_team = CourseTeamFactory.create(
|
||
name='Another Team',
|
||
course_id=cls.test_course_2.id,
|
||
topic_id='topic_5'
|
||
)
|
||
cls.public_profile_team = CourseTeamFactory.create(
|
||
name='Public Profile Team',
|
||
course_id=cls.test_course_2.id,
|
||
topic_id='topic_6'
|
||
)
|
||
cls.search_team = CourseTeamFactory.create(
|
||
name='Search',
|
||
description='queryable text',
|
||
country='GS',
|
||
language='to',
|
||
course_id=cls.test_course_2.id,
|
||
topic_id='topic_7'
|
||
)
|
||
cls.chinese_team = CourseTeamFactory.create(
|
||
name='著文企臺個',
|
||
description='共樣地面較，件展冷不護者這與民教過住意，國制銀產物助音是勢一友',
|
||
country='CN',
|
||
language='zh_HANS',
|
||
course_id=cls.test_course_2.id,
|
||
topic_id='topic_7'
|
||
)
|
||
|
||
cls.masters_only_team = CourseTeamFactory.create(
|
||
name='masters_course_1',
|
||
description='masters student group',
|
||
country='US',
|
||
language='EN',
|
||
course_id=cls.test_course_1.id,
|
||
topic_id='topic_0',
|
||
organization_protected=True
|
||
)
|
||
|
||
cls.team_1_in_private_teamset_1 = CourseTeamFactory.create(
|
||
name='team 1 in private teamset 1',
|
||
description='team 1 in private teamset 1 desc',
|
||
country='US',
|
||
language='EN',
|
||
course_id=cls.test_course_1.id,
|
||
topic_id='private_topic_1_id',
|
||
organization_protected=True
|
||
)
|
||
|
||
cls.team_2_in_private_teamset_1 = CourseTeamFactory.create(
|
||
name='team 2 in private teamset 1',
|
||
description='team 2 in private teamset 1 desc',
|
||
country='US',
|
||
language='EN',
|
||
course_id=cls.test_course_1.id,
|
||
topic_id='private_topic_1_id',
|
||
organization_protected=True
|
||
)
|
||
|
||
cls.team_1_in_private_teamset_2 = CourseTeamFactory.create(
|
||
name='team 1 in private teamset 2',
|
||
description='team 1 in private teamset 2 desc',
|
||
country='US',
|
||
language='EN',
|
||
course_id=cls.test_course_1.id,
|
||
topic_id='private_topic_2_id',
|
||
organization_protected=True
|
||
)
|
||
|
||
cls.test_team_name_id_map = {team.name: team for team in (
|
||
cls.solar_team,
|
||
cls.wind_team,
|
||
cls.nuclear_team,
|
||
cls.another_team,
|
||
cls.public_profile_team,
|
||
cls.search_team,
|
||
cls.chinese_team,
|
||
cls.masters_only_team,
|
||
cls.team_1_in_private_teamset_1,
|
||
cls.team_2_in_private_teamset_1,
|
||
cls.team_1_in_private_teamset_2,
|
||
)}
|
||
|
||
for user, course in [('staff', cls.test_course_1), ('course_staff', cls.test_course_1)]:
|
||
CourseEnrollment.enroll(
|
||
cls.users[user], course.id, check_access=True
|
||
)
|
||
|
||
# Django Rest Framework v3 requires us to pass a request to serializers
|
||
# that have URL fields. Since we're invoking this code outside the context
|
||
# of a request, we need to simulate that there's a request.
|
||
cls.solar_team.add_user(cls.users['student_enrolled'])
|
||
cls.nuclear_team.add_user(cls.users['student_enrolled_both_courses_other_team'])
|
||
cls.another_team.add_user(cls.users['student_enrolled_both_courses_other_team'])
|
||
cls.public_profile_team.add_user(cls.users['student_enrolled_public_profile'])
|
||
cls.masters_only_team.add_user(cls.users['student_masters'])
|
||
cls.team_1_in_private_teamset_1.add_user(cls.users['student_on_team_1_private_set_1'])
|
||
cls.team_2_in_private_teamset_1.add_user(cls.users['student_on_team_2_private_set_1'])
|
||
|
||
def build_membership_data_raw(self, username, team):
|
||
"""Assembles a membership creation payload based on the raw values provided."""
|
||
return {'username': username, 'team_id': team}
|
||
|
||
def build_membership_data(self, username, team):
|
||
"""Assembles a membership creation payload based on the username and team model provided."""
|
||
return self.build_membership_data_raw(self.users[username].username, team.team_id)
|
||
|
||
@classmethod
|
||
def create_and_enroll_student(cls, courses=None, username=None, mode=None, external_key=None):
|
||
""" Creates a new student and enrolls that student in the course.
|
||
|
||
Adds the new user to the cls.users dictionary with the username as the key.
|
||
|
||
Returns the username once the user has been created.
|
||
"""
|
||
if username is not None:
|
||
user = UserFactory.create(password=cls.test_password, username=username)
|
||
else:
|
||
user = UserFactory.create(password=cls.test_password)
|
||
courses = courses if courses is not None else [cls.test_course_1]
|
||
for course in courses:
|
||
CourseEnrollment.enroll(user, course.id, mode=mode, check_access=True)
|
||
cls.users[user.username] = user
|
||
|
||
if external_key is not None:
|
||
ProgramEnrollmentFactory(
|
||
user=user,
|
||
external_user_key=external_key,
|
||
program_uuid=UUID("88888888-4444-3333-1111-000000000000"),
|
||
curriculum_uuid=UUID("77777777-4444-2222-1111-000000000000"),
|
||
status='enrolled'
|
||
)
|
||
|
||
return user.username
|
||
|
||
def login(self, user):
|
||
"""Given a user string, logs the given user in.
|
||
|
||
Used for testing with ddt, which does not have access to self in
|
||
decorators. If user is 'student_inactive', then an inactive user will
|
||
be both created and logged in.
|
||
"""
|
||
if user == 'student_inactive':
|
||
student_inactive = UserFactory.create(password=self.test_password)
|
||
self.client.login(username=student_inactive.username, password=self.test_password)
|
||
student_inactive.is_active = False
|
||
student_inactive.save()
|
||
else:
|
||
self.client.login(username=self.users[user].username, password=self.test_password)
|
||
|
||
def make_call(self, url, expected_status=200, method='get', data=None, content_type=None, **kwargs):
|
||
"""Makes a call to the Team API at the given url with method and data.
|
||
|
||
If a user is specified in kwargs, that user is first logged in.
|
||
"""
|
||
user = kwargs.pop('user', 'student_enrolled_not_on_team')
|
||
if user:
|
||
self.login(user)
|
||
func = getattr(self.client, method)
|
||
if content_type:
|
||
response = func(url, data=data, content_type=content_type)
|
||
else:
|
||
response = func(url, data=data)
|
||
assert expected_status == response.status_code, "Expected status {expected} but got {actual}: {content}"\
|
||
.format(expected=expected_status, actual=response.status_code,
|
||
content=response.content.decode(response.charset))
|
||
|
||
if expected_status == 200:
|
||
return json.loads(response.content.decode('utf-8'))
|
||
else:
|
||
return response
|
||
|
||
def get_teams_list(self, expected_status=200, data=None, no_course_id=False, **kwargs):
|
||
"""Gets the list of teams as the given user with data as query params. Verifies expected_status."""
|
||
data = data if data else {}
|
||
if 'course_id' not in data and not no_course_id:
|
||
data.update({'course_id': str(self.test_course_1.id)})
|
||
return self.make_call(reverse('teams_list'), expected_status, 'get', data, **kwargs)
|
||
|
||
def get_user_course_specific_teams_list(self):
|
||
"""Gets the list of user course specific teams."""
|
||
|
||
# Create and enroll user in both courses
|
||
user = self.create_and_enroll_student(
|
||
courses=[self.test_course_1, self.test_course_2],
|
||
username='test_user_enrolled_both_courses'
|
||
)
|
||
course_one_data = {'course_id': str(self.test_course_1.id), 'username': user}
|
||
course_two_data = {'course_id': str(self.test_course_2.id), 'username': user}
|
||
|
||
# Check that initially list of user teams in course one is empty
|
||
team_list = self.get_teams_list(user=user, expected_status=200, data=course_one_data)
|
||
assert team_list['count'] == 0
|
||
|
||
# Add user to a course one team
|
||
self.solar_team.add_user(self.users[user])
|
||
|
||
# Check that list of user teams in course one is not empty now
|
||
team_list = self.get_teams_list(user=user, expected_status=200, data=course_one_data)
|
||
assert team_list['count'] == 1
|
||
|
||
# Check that list of user teams in course two is still empty
|
||
team_list = self.get_teams_list(user=user, expected_status=200, data=course_two_data)
|
||
assert team_list['count'] == 0
|
||
|
||
def build_team_data(
|
||
self,
|
||
name="Test team",
|
||
course=None,
|
||
description="Filler description",
|
||
topic_id="topic_0",
|
||
**kwargs
|
||
):
|
||
"""Creates the payload for creating a team. kwargs can be used to specify additional fields."""
|
||
data = kwargs
|
||
course = course if course else self.test_course_1
|
||
data.update({
|
||
'name': name,
|
||
'course_id': str(course.id),
|
||
'description': description,
|
||
'topic_id': topic_id,
|
||
})
|
||
return data
|
||
|
||
def post_create_team(self, expected_status=200, data=None, **kwargs):
|
||
"""Posts data to the team creation endpoint. Verifies expected_status."""
|
||
#return self.make_call(reverse('teams_list'), expected_status, 'post', data, topic_id='topic_0', **kwargs)
|
||
return self.make_call(reverse('teams_list'), expected_status, 'post', data, **kwargs)
|
||
|
||
def get_team_detail(self, team_id, expected_status=200, data=None, **kwargs):
|
||
"""Gets detailed team information for team_id. Verifies expected_status."""
|
||
return self.make_call(reverse('teams_detail', args=[team_id]), expected_status, 'get', data, **kwargs)
|
||
|
||
def delete_team(self, team_id, expected_status, **kwargs):
|
||
"""Delete the given team. Verifies expected_status."""
|
||
return self.make_call(reverse('teams_detail', args=[team_id]), expected_status, 'delete', **kwargs)
|
||
|
||
def patch_team_detail(self, team_id, expected_status, data=None, **kwargs):
|
||
"""Patches the team with team_id using data. Verifies expected_status."""
|
||
return self.make_call(
|
||
reverse('teams_detail', args=[team_id]),
|
||
expected_status,
|
||
'patch',
|
||
json.dumps(data) if data else None,
|
||
'application/merge-patch+json',
|
||
**kwargs
|
||
)
|
||
|
||
def get_team_assignments(self, team_id, expected_status=200, **kwargs):
|
||
""" Get the open response assessments assigned to a team """
|
||
return self.make_call(
|
||
reverse('teams_assignments_list', args=[team_id]),
|
||
expected_status,
|
||
**kwargs
|
||
)
|
||
|
||
def get_topics_list(self, expected_status=200, data=None, **kwargs):
|
||
"""Gets the list of topics, passing data as query params. Verifies expected_status."""
|
||
return self.make_call(reverse('topics_list'), expected_status, 'get', data, **kwargs)
|
||
|
||
def get_topic_detail(self, topic_id, course_id, expected_status=200, data=None, **kwargs):
|
||
"""Gets a single topic, passing data as query params. Verifies expected_status."""
|
||
return self.make_call(
|
||
reverse('topics_detail', kwargs={'topic_id': topic_id, 'course_id': str(course_id)}),
|
||
expected_status,
|
||
'get',
|
||
data,
|
||
**kwargs
|
||
)
|
||
|
||
def get_membership_list(self, expected_status=200, data=None, **kwargs):
|
||
"""Gets the membership list, passing data as query params. Verifies expected_status."""
|
||
return self.make_call(reverse('team_membership_list'), expected_status, 'get', data, **kwargs)
|
||
|
||
def post_create_membership(self, expected_status=200, data=None, **kwargs):
|
||
"""Posts data to the membership creation endpoint. Verifies expected_status."""
|
||
return self.make_call(reverse('team_membership_list'), expected_status, 'post', data, **kwargs)
|
||
|
||
def get_membership_detail(self, team_id, username, expected_status=200, data=None, **kwargs):
|
||
"""Gets an individual membership record, passing data as query params. Verifies expected_status."""
|
||
return self.make_call(
|
||
reverse('team_membership_detail', args=[team_id, username]),
|
||
expected_status,
|
||
'get',
|
||
data,
|
||
**kwargs
|
||
)
|
||
|
||
def delete_membership(self, team_id, username, expected_status=200, **kwargs):
|
||
"""Deletes an individual membership record. Verifies expected_status."""
|
||
url = reverse('team_membership_detail', args=[team_id, username]) + '?admin=true'
|
||
return self.make_call(url, expected_status, 'delete', **kwargs)
|
||
|
||
def verify_expanded_public_user(self, user):
|
||
"""Verifies that fields exist on the returned user json indicating that it is expanded."""
|
||
for field in ['username', 'url', 'bio', 'country', 'profile_image', 'time_zone', 'language_proficiencies']:
|
||
assert field in user
|
||
|
||
def verify_expanded_private_user(self, user):
|
||
"""Verifies that fields exist on the returned user json indicating that it is expanded."""
|
||
for field in ['username', 'url', 'profile_image']:
|
||
assert field in user
|
||
for field in ['bio', 'country', 'time_zone', 'language_proficiencies']:
|
||
assert field not in user
|
||
|
||
def verify_expanded_team(self, team):
|
||
"""Verifies that fields exist on the returned team json indicating that it is expanded."""
|
||
for field in ['id', 'name', 'course_id', 'topic_id', 'date_created', 'description']:
|
||
assert field in team
|
||
|
||
def reset_search_index(self):
|
||
"""Clear out the search index and reindex the teams."""
|
||
CourseTeamIndexer.engine().destroy()
|
||
for team in self.test_team_name_id_map.values():
|
||
CourseTeamIndexer.index(team)
|
||
|
||
|
||
@ddt.ddt
|
||
class TestListTeamsAPI(EventTestMixin, TeamAPITestCase):
|
||
"""Test cases for the team listing API endpoint."""
|
||
|
||
def setUp(self): # pylint: disable=arguments-differ
|
||
super().setUp('lms.djangoapps.teams.utils.tracker')
|
||
|
||
@ddt.data(
|
||
(None, 401),
|
||
('student_inactive', 401),
|
||
('student_unenrolled', 403),
|
||
('student_enrolled', 200, 3),
|
||
('staff', 200, 7),
|
||
('course_staff', 200, 7),
|
||
('community_ta', 200, 3),
|
||
('student_masters', 200, 1)
|
||
)
|
||
@ddt.unpack
|
||
def test_access(self, user, status, expected_teams_count=0):
|
||
teams = self.get_teams_list(user=user, expected_status=status)
|
||
if status == 200:
|
||
assert expected_teams_count == teams['count']
|
||
|
||
def test_missing_course_id(self):
|
||
self.get_teams_list(400, no_course_id=True)
|
||
|
||
def verify_names(self, data, status, names=None, **kwargs):
|
||
"""Gets a team listing with data as query params, verifies status, and then verifies team names if specified."""
|
||
teams = self.get_teams_list(data=data, expected_status=status, **kwargs)
|
||
if names is not None and 200 <= status < 300:
|
||
results = teams['results']
|
||
assert sorted(names) == sorted([team['name'] for team in results])
|
||
|
||
def test_filter_invalid_course_id(self):
|
||
self.verify_names({'course_id': 'no_such_course'}, 400)
|
||
|
||
def test_filter_course_id(self):
|
||
self.verify_names(
|
||
{'course_id': str(self.test_course_2.id)},
|
||
200,
|
||
['Another Team', 'Public Profile Team', 'Search', '著文企臺個'],
|
||
user='staff'
|
||
)
|
||
|
||
def test_filter_topic_id(self):
|
||
self.verify_names({'course_id': str(self.test_course_1.id), 'topic_id': 'topic_0'}, 200, ['Sólar team'])
|
||
|
||
def test_filter_username(self):
|
||
self.verify_names({'course_id': str(self.test_course_1.id),
|
||
'username': 'student_enrolled'}, 200, ['Sólar team'])
|
||
self.verify_names({'course_id': str(self.test_course_1.id), 'username': 'staff'}, 200, [])
|
||
|
||
@ddt.data(
|
||
(None, 200, ['Nuclear Team', 'Sólar team', 'Wind Team']),
|
||
('name', 200, ['Nuclear Team', 'Sólar team', 'Wind Team']),
|
||
# Note that "Nuclear Team" and "Solar team" have the same open_slots.
|
||
# "Solar team" comes first due to secondary sort by last_activity_at.
|
||
('open_slots', 200, ['Wind Team', 'Sólar team', 'Nuclear Team']),
|
||
# Note that "Wind Team" and "Nuclear Team" have the same last_activity_at.
|
||
# "Wind Team" comes first due to secondary sort by open_slots.
|
||
('last_activity_at', 200, ['Sólar team', 'Wind Team', 'Nuclear Team']),
|
||
)
|
||
@ddt.unpack
|
||
def test_order_by(self, field, status, names):
|
||
# Make "Solar team" the most recently active team.
|
||
# The CourseTeamFactory sets the last_activity_at to a fixed time (in the past), so all of the
|
||
# other teams have the same last_activity_at.
|
||
with skip_signal(
|
||
post_save,
|
||
receiver=course_team_post_save_callback,
|
||
sender=CourseTeam,
|
||
dispatch_uid='teams.signals.course_team_post_save_callback'
|
||
):
|
||
solar_team = self.test_team_name_id_map['Sólar team']
|
||
solar_team.last_activity_at = datetime.utcnow().replace(tzinfo=pytz.utc)
|
||
solar_team.save()
|
||
|
||
data = {'order_by': field} if field else {}
|
||
self.verify_names(data, status, names)
|
||
|
||
def test_order_by_with_text_search(self):
|
||
data = {'order_by': 'name', 'text_search': 'search'}
|
||
self.verify_names(data, 400, [])
|
||
self.assert_no_events_were_emitted()
|
||
|
||
@ddt.data((404, {'course_id': 'no/such/course'}), (400, {'topic_id': 'no_such_topic'}))
|
||
@ddt.unpack
|
||
def test_no_results(self, status, data):
|
||
self.get_teams_list(status, data)
|
||
|
||
def test_page_size(self):
|
||
result = self.get_teams_list(200, {'page_size': 2})
|
||
assert 2 == result['num_pages']
|
||
|
||
def test_non_member_trying_to_get_private_topic(self):
|
||
"""
|
||
Verifies that when a student that is enrolled in a course, but is NOT a member of
|
||
a private team set, asks for information about that team set, an empty list is returned.
|
||
"""
|
||
result = self.get_teams_list(data={'topic_id': 'private_topic_1_id'})
|
||
assert [] == result['results']
|
||
|
||
def test_member_trying_to_get_private_topic(self):
|
||
"""
|
||
Verifies that when a student that is enrolled in a course, and IS a member of
|
||
a private team set, asks for information about that team set, information about the teamset is returned.
|
||
"""
|
||
result = self.get_teams_list(data={'topic_id': 'private_topic_1_id'},
|
||
user='student_on_team_1_private_set_1')
|
||
assert 1 == len(result['results'])
|
||
assert 'private_topic_1_id' == result['results'][0]['topic_id']
|
||
assert [] != result['results']
|
||
|
||
def test_course_staff_getting_information_on_private_topic(self):
|
||
"""
|
||
Verifies that when an admin browses to a private team set,
|
||
information about the teams in the teamset is returned even if the admin is not in any teams.
|
||
"""
|
||
result = self.get_teams_list(data={'topic_id': 'private_topic_1_id'},
|
||
user='course_staff')
|
||
assert 2 == len(result['results'])
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_masters_not_on_team', 1),
|
||
('student_masters', 1),
|
||
('student_enrolled', 0),
|
||
('staff', 1),
|
||
)
|
||
def test_text_search_organization_protected(self, user, expected_results):
|
||
"""
|
||
When doing a text search as different users, will the masters_only team show up?
|
||
Only staff, or people who are within the organization_protected bubble should be
|
||
able to see the masters team
|
||
"""
|
||
self.reset_search_index()
|
||
result = self.get_teams_list(
|
||
data={'text_search': 'master'},
|
||
user=user,
|
||
)
|
||
assert result['count'] == expected_results
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_on_team_1_private_set_1', True, False, False),
|
||
('student_on_team_2_private_set_1', False, True, False),
|
||
('student_enrolled', False, False, False),
|
||
('student_masters', False, False, False),
|
||
('staff', True, True, True),
|
||
)
|
||
def test_text_search_private_teamset(self, user, can_see_private_1_1, can_see_private_1_2, can_see_private_2_1):
|
||
"""
|
||
When doing a text search as different users, will private_managed teams show up?
|
||
Only staff should be able to see all private_managed teams.
|
||
Students enrolled in a private_managed teams should be able to see their team, and no others.
|
||
"""
|
||
self.reset_search_index()
|
||
result = self.get_teams_list(
|
||
data={'text_search': 'private'},
|
||
user=user,
|
||
)
|
||
teams = {team['name'] for team in result['results']}
|
||
expected_teams = set()
|
||
if can_see_private_1_1:
|
||
expected_teams.add(self.team_1_in_private_teamset_1.name)
|
||
if can_see_private_1_2:
|
||
expected_teams.add(self.team_2_in_private_teamset_1.name)
|
||
if can_see_private_2_1:
|
||
expected_teams.add(self.team_1_in_private_teamset_2.name)
|
||
assert expected_teams == teams
|
||
|
||
def test_page(self):
|
||
result = self.get_teams_list(200, {'page_size': 1, 'page': 3})
|
||
assert 3 == result['num_pages']
|
||
assert result['next'] is None
|
||
assert result['previous'] is not None
|
||
|
||
def test_expand_private_user(self):
|
||
# Use the default user which is already private because to year_of_birth is set
|
||
result = self.get_teams_list(200, {'expand': 'user', 'topic_id': 'topic_0'})
|
||
self.verify_expanded_private_user(result['results'][0]['membership'][0]['user'])
|
||
|
||
def test_expand_public_user(self):
|
||
result = self.get_teams_list(
|
||
200,
|
||
{
|
||
'expand': 'user',
|
||
'topic_id': 'topic_6',
|
||
'course_id': str(self.test_course_2.id)
|
||
},
|
||
user='student_enrolled_public_profile'
|
||
)
|
||
self.verify_expanded_public_user(result['results'][0]['membership'][0]['user'])
|
||
|
||
@ddt.data(
|
||
('search', ['Search']),
|
||
('queryable', ['Search']),
|
||
('Tonga', ['Search']),
|
||
('Island', ['Search']),
|
||
('not-a-query', []),
|
||
('team', ['Another Team', 'Public Profile Team']),
|
||
('著文企臺個', ['著文企臺個']),
|
||
)
|
||
@ddt.unpack
|
||
def test_text_search(self, text_search, expected_team_names):
|
||
self.reset_search_index()
|
||
self.verify_names(
|
||
{'course_id': str(self.test_course_2.id), 'text_search': text_search},
|
||
200,
|
||
expected_team_names,
|
||
user='student_enrolled_public_profile'
|
||
)
|
||
|
||
self.assert_event_emitted(
|
||
'edx.team.searched',
|
||
search_text=text_search,
|
||
topic_id=None,
|
||
number_of_results=len(expected_team_names)
|
||
)
|
||
|
||
# Verify that the searches still work for a user from a different locale
|
||
with translation.override('ar'):
|
||
self.reset_search_index()
|
||
self.verify_names(
|
||
{'course_id': str(self.test_course_2.id), 'text_search': text_search},
|
||
200,
|
||
expected_team_names,
|
||
user='student_enrolled_public_profile'
|
||
)
|
||
|
||
@ddt.data(
|
||
('masters', ['masters_course_1']),
|
||
('group', ['masters_course_1']),
|
||
('Sólar', []),
|
||
('Wind', []),
|
||
)
|
||
@ddt.unpack
|
||
def test_text_search_masters(self, text_search, expected_team_names):
|
||
# Verify that the search is working with Masters learner
|
||
self.reset_search_index()
|
||
self.verify_names(
|
||
{'course_id': str(self.test_course_1.id), 'text_search': text_search},
|
||
200,
|
||
expected_team_names,
|
||
user='student_masters'
|
||
)
|
||
|
||
def test_delete_removed_from_search(self):
|
||
team = CourseTeamFactory.create(
|
||
name='zoinks',
|
||
course_id=self.test_course_1.id,
|
||
topic_id='topic_0'
|
||
)
|
||
self.verify_names(
|
||
{'course_id': str(self.test_course_1.id), 'text_search': 'zoinks'},
|
||
200,
|
||
[team.name],
|
||
user='staff'
|
||
)
|
||
team.delete()
|
||
self.verify_names(
|
||
{'course_id': str(self.test_course_1.id), 'text_search': 'zoinks'},
|
||
200,
|
||
[],
|
||
user='staff'
|
||
)
|
||
|
||
def test_duplicates_and_nontopic_private_teamsets(self):
|
||
"""
|
||
Test for a bug where non-admin users would have their private memberships returned from this endpoint
|
||
despite the topic, and duplicate entries for teams in the topic that was being queried (EDUCATOR-5042)
|
||
"""
|
||
# create a team in a private teamset and add a user
|
||
unprotected_team_in_private_teamset = CourseTeamFactory.create(
|
||
name='unprotected_team_in_private_teamset',
|
||
description='unprotected_team_in_private_teamset',
|
||
course_id=self.test_course_1.id,
|
||
topic_id='private_topic_1_id',
|
||
)
|
||
unprotected_team_in_private_teamset.add_user(self.users['student_enrolled'])
|
||
|
||
# make some more users and put them in the solar team.
|
||
another_student_username = 'another_student'
|
||
yet_another_student_username = 'yet_another_student'
|
||
self.create_and_enroll_student(username=another_student_username)
|
||
self.create_and_enroll_student(username=yet_another_student_username)
|
||
self.solar_team.add_user(self.users[another_student_username])
|
||
self.solar_team.add_user(self.users[yet_another_student_username])
|
||
|
||
teams = self.get_teams_list(data={'topic_id': self.solar_team.topic_id}, user='student_enrolled')
|
||
team_names = [team['name'] for team in teams['results']]
|
||
team_names.sort()
|
||
assert team_names == [self.solar_team.name]
|
||
|
||
teams = self.get_teams_list(data={'topic_id': self.solar_team.topic_id}, user='staff')
|
||
team_names = [team['name'] for team in teams['results']]
|
||
team_names.sort()
|
||
assert team_names == [self.solar_team.name, self.masters_only_team.name]
|
||
|
||
|
||
@ddt.ddt
|
||
class TestCreateTeamAPI(EventTestMixin, TeamAPITestCase):
|
||
"""Test cases for the team creation endpoint."""
|
||
|
||
def setUp(self): # pylint: disable=arguments-differ
|
||
super().setUp('lms.djangoapps.teams.utils.tracker')
|
||
|
||
@ddt.data(
|
||
(None, 401),
|
||
('student_inactive', 401),
|
||
('student_unenrolled', 403),
|
||
('student_enrolled_not_on_team', 200),
|
||
('staff', 200),
|
||
('course_staff', 200),
|
||
('community_ta', 200),
|
||
)
|
||
@ddt.unpack
|
||
def test_access(self, user, status):
|
||
team = self.post_create_team(status, self.build_team_data(name="New Team"), user=user)
|
||
if status == 200:
|
||
self.verify_expected_team_id(team, 'new-team')
|
||
teams = self.get_teams_list(user=user)
|
||
assert 'New Team' in [team['name'] for team in teams['results']]
|
||
|
||
def _expected_team_id(self, team, expected_prefix):
|
||
""" Return the team id that we'd expect given this team data and this prefix. """
|
||
return expected_prefix + '-' + team['discussion_topic_id']
|
||
|
||
def verify_expected_team_id(self, team, expected_prefix):
|
||
""" Verifies that the team id starts with the specified prefix and ends with the discussion_topic_id """
|
||
assert 'id' in team
|
||
assert 'discussion_topic_id' in team
|
||
assert team['id'] == self._expected_team_id(team, expected_prefix)
|
||
|
||
def test_naming(self):
|
||
new_teams = [
|
||
self.post_create_team(data=self.build_team_data(name=name), user=self.create_and_enroll_student())
|
||
for name in ["The Best Team", "The Best Team", "A really long team name"]
|
||
]
|
||
# Check that teams with the same name have unique IDs.
|
||
self.verify_expected_team_id(new_teams[0], 'the-best-team')
|
||
self.verify_expected_team_id(new_teams[1], 'the-best-team')
|
||
assert new_teams[0]['id'] != new_teams[1]['id']
|
||
|
||
# Verify expected truncation behavior with names > 20 characters.
|
||
self.verify_expected_team_id(new_teams[2], 'a-really-long-team-n')
|
||
|
||
@ddt.data((400, {
|
||
'name': 'Bad Course ID',
|
||
'course_id': 'no_such_course',
|
||
'description': "Filler Description"
|
||
}), (404, {
|
||
'name': "Non-existent course ID",
|
||
'course_id': 'no/such/course',
|
||
'description': "Filler Description"
|
||
}))
|
||
@ddt.unpack
|
||
def test_bad_course_data(self, status, data):
|
||
self.post_create_team(status, data)
|
||
|
||
def test_bad_topic_id(self):
|
||
self.post_create_team(
|
||
404,
|
||
data=self.build_team_data(topic_id='asdfasdfasdfa'),
|
||
user='staff'
|
||
)
|
||
|
||
def test_missing_topic_id(self):
|
||
data = self.build_team_data()
|
||
data.pop('topic_id')
|
||
self.post_create_team(400, data=data, user='staff')
|
||
|
||
def test_student_in_teamset(self):
|
||
response = self.post_create_team(
|
||
400,
|
||
data=self.build_team_data(
|
||
name="Doomed team",
|
||
course=self.test_course_1,
|
||
description="Overly ambitious student"
|
||
),
|
||
user='student_enrolled'
|
||
)
|
||
assert 'You are already in a team in this teamset.' ==\
|
||
json.loads(response.content.decode('utf-8'))['user_message']
|
||
|
||
@patch('lms.djangoapps.teams.views.can_user_create_team_in_topic', return_value=False)
|
||
@patch('lms.djangoapps.teams.views.has_specific_teamset_access', return_value=True)
|
||
def test_student_create_team_instructor_managed_topic(self, *args): # pylint: disable=unused-argument
|
||
response = self.post_create_team(
|
||
403,
|
||
data=self.build_team_data(
|
||
name="student create team in instructor managed topic",
|
||
course=self.test_course_1,
|
||
description="student cannot create team in instructor-managed topic",
|
||
topic_id='private_topic_1_id'
|
||
),
|
||
user='student_enrolled_not_on_team'
|
||
)
|
||
assert "You can't create a team in an instructor managed topic." ==\
|
||
json.loads(response.content.decode('utf-8'))['user_message']
|
||
|
||
@ddt.data('staff', 'course_staff', 'community_ta')
|
||
def test_privileged_create_multiple_teams(self, user):
|
||
""" Privileged users can create multiple teams, even if they are already in one. """
|
||
# First add the privileged user to a team.
|
||
self.post_create_membership(
|
||
200,
|
||
self.build_membership_data(user, self.solar_team),
|
||
user=user
|
||
)
|
||
|
||
self.post_create_team(
|
||
data=self.build_team_data(
|
||
name="Another team",
|
||
course=self.test_course_1,
|
||
description="Privileged users are the best",
|
||
topic_id=self.solar_team.topic_id
|
||
),
|
||
user=user
|
||
)
|
||
|
||
@ddt.data({'description': ''}, {'name': 'x' * 1000}, {'name': ''})
|
||
def test_bad_fields(self, kwargs):
|
||
self.post_create_team(400, self.build_team_data(**kwargs))
|
||
|
||
def test_missing_name(self):
|
||
self.post_create_team(400, {
|
||
'course_id': str(self.test_course_1.id),
|
||
'description': "foobar"
|
||
})
|
||
|
||
def test_full_student_creator(self):
|
||
creator = self.create_and_enroll_student()
|
||
team = self.post_create_team(data=self.build_team_data(
|
||
name="Fully specified team",
|
||
course=self.test_course_1,
|
||
description="Another fantastic team",
|
||
topic_id='topic_1',
|
||
country='CA',
|
||
language='fr'
|
||
), user=creator)
|
||
|
||
# Verify the id (it ends with a unique hash, which is the same as the discussion_id).
|
||
self.verify_expected_team_id(team, 'fully-specified-team')
|
||
del team['id']
|
||
|
||
self.assert_event_emitted(
|
||
'edx.team.created',
|
||
team_id=self._expected_team_id(team, 'fully-specified-team'),
|
||
)
|
||
|
||
self.assert_event_emitted(
|
||
'edx.team.learner_added',
|
||
team_id=self._expected_team_id(team, 'fully-specified-team'),
|
||
user_id=self.users[creator].id,
|
||
add_method='added_on_create'
|
||
)
|
||
# Remove date_created and discussion_topic_id because they change between test runs
|
||
del team['date_created']
|
||
del team['discussion_topic_id']
|
||
|
||
# Since membership is its own list, we want to examine this separately.
|
||
team_membership = team['membership']
|
||
del team['membership']
|
||
|
||
# verify that it's been set to a time today.
|
||
assert parser.parse(team['last_activity_at']).date() == datetime.utcnow().replace(tzinfo=pytz.utc).date()
|
||
del team['last_activity_at']
|
||
|
||
# Verify that the creating user gets added to the team.
|
||
assert len(team_membership) == 1
|
||
member = team_membership[0]['user']
|
||
assert member['username'] == creator
|
||
|
||
assert team == {'name': 'Fully specified team', 'language': 'fr', 'country': 'CA', 'topic_id': 'topic_1',
|
||
'course_id': str(self.test_course_1.id), 'description': 'Another fantastic team',
|
||
'organization_protected': False}
|
||
|
||
@ddt.data('staff', 'course_staff', 'community_ta')
|
||
def test_membership_staff_creator(self, user):
|
||
# Verify that staff do not automatically get added to a team
|
||
# when they create one.
|
||
team = self.post_create_team(data=self.build_team_data(
|
||
name="New team",
|
||
course=self.test_course_1,
|
||
description="Another fantastic team",
|
||
), user=user)
|
||
|
||
assert team['membership'] == []
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_enrolled', 404, None),
|
||
('student_unenrolled', 403, None),
|
||
('student_enrolled_not_on_team', 404, None),
|
||
('student_masters', 404, None),
|
||
('student_on_team_1_private_set_1', 403, "You can't create a team in an instructor managed topic."),
|
||
('student_on_team_2_private_set_1', 403, "You can't create a team in an instructor managed topic."),
|
||
('staff', 200, None)
|
||
)
|
||
def test_private_managed_access(self, user, expected_response, msg):
|
||
"""
|
||
As different users, check if we can create a team in a private teamset.
|
||
Only staff should be able to create teams in managed teamsets, but they're also
|
||
the only ones who should know that private_managed teamsets exist. If the team hasn't been created yet,
|
||
no one can be in it, so no non-staff should get any info at all from this endpoint.
|
||
"""
|
||
response = self.post_create_team(
|
||
expected_response,
|
||
data=self.build_team_data(
|
||
name="test_private_managed_access",
|
||
course=self.test_course_1,
|
||
description="test_private_managed_access",
|
||
topic_id="private_topic_1_id"
|
||
),
|
||
user=user
|
||
)
|
||
if msg:
|
||
assert msg == response.json()['user_message']
|
||
|
||
|
||
@ddt.ddt
|
||
class TestDetailTeamAPI(TeamAPITestCase):
|
||
"""Test cases for the team detail endpoint."""
|
||
|
||
@ddt.data(
|
||
(None, 401),
|
||
('student_inactive', 401),
|
||
('student_unenrolled', 403),
|
||
('student_enrolled', 200),
|
||
('staff', 200),
|
||
('course_staff', 200),
|
||
('community_ta', 200),
|
||
)
|
||
@ddt.unpack
|
||
def test_access(self, user, status):
|
||
team = self.get_team_detail(self.solar_team.team_id, status, user=user)
|
||
if status == 200:
|
||
assert team['description'] == self.solar_team.description
|
||
assert team['discussion_topic_id'] == self.solar_team.discussion_topic_id
|
||
assert parser.parse(team['last_activity_at']) == LAST_ACTIVITY_AT
|
||
|
||
def test_does_not_exist(self):
|
||
self.get_team_detail('no_such_team', 404)
|
||
|
||
def test_expand_private_user(self):
|
||
# Use the default user which is already private because to year_of_birth is set
|
||
result = self.get_team_detail(self.solar_team.team_id, 200, {'expand': 'user'})
|
||
self.verify_expanded_private_user(result['membership'][0]['user'])
|
||
|
||
def test_expand_public_user(self):
|
||
result = self.get_team_detail(
|
||
self.public_profile_team.team_id,
|
||
200,
|
||
{'expand': 'user'},
|
||
user='student_enrolled_public_profile'
|
||
)
|
||
self.verify_expanded_public_user(result['membership'][0]['user'])
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_unenrolled', 403),
|
||
('student_enrolled', 404),
|
||
('student_masters_not_on_team', 200),
|
||
('student_masters', 200),
|
||
('staff', 200)
|
||
)
|
||
def test_organization_protected(self, requesting_user, expected_response):
|
||
"""
|
||
As different users, check if we can request the masters_only team detail.
|
||
Only staff and users within the organization_protection bubble should be able to get info about
|
||
an organization_protected team, or be able to tell that it exists.
|
||
"""
|
||
team = self.get_team_detail(
|
||
self.masters_only_team.team_id,
|
||
expected_response,
|
||
user=requesting_user
|
||
)
|
||
if expected_response == 200:
|
||
assert team['name'] == self.masters_only_team.name
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_unenrolled', 403),
|
||
('student_enrolled', 404),
|
||
('student_masters', 404),
|
||
('student_on_team_1_private_set_1', 200),
|
||
('student_on_team_2_private_set_1', 404),
|
||
('staff', 200)
|
||
)
|
||
def test_teamset_types(self, requesting_user, expected_response):
|
||
"""
|
||
As different users, check if we can request the masters_only team detail.
|
||
Only staff or users enrolled in the team should be able to get info about a private_managed team,
|
||
or even be able to tell that it exists.
|
||
"""
|
||
team = self.get_team_detail(
|
||
self.team_1_in_private_teamset_1.team_id,
|
||
expected_response,
|
||
user=requesting_user
|
||
)
|
||
if expected_response == 200:
|
||
assert team['name'] == self.team_1_in_private_teamset_1.name
|
||
|
||
|
||
@ddt.ddt
|
||
class TestDeleteTeamAPI(EventTestMixin, TeamAPITestCase):
|
||
"""Test cases for the team delete endpoint."""
|
||
|
||
def setUp(self): # pylint: disable=arguments-differ
|
||
super().setUp('lms.djangoapps.teams.utils.tracker')
|
||
|
||
@ddt.data(
|
||
('staff', 204),
|
||
('course_staff', 204),
|
||
('community_ta', 204),
|
||
('admin', 204)
|
||
)
|
||
@ddt.unpack
|
||
def test_access(self, user, status):
|
||
team_list = self.get_teams_list(user='course_staff', expected_status=200)
|
||
previous_count = team_list['count']
|
||
assert self.solar_team.team_id in [result['id'] for result in team_list.get('results')]
|
||
self.delete_team(self.solar_team.team_id, status, user=user)
|
||
|
||
team_list = self.get_teams_list(user='course_staff', expected_status=200)
|
||
assert team_list['count'] == (previous_count - 1)
|
||
assert self.solar_team.team_id not in [result['id'] for result in team_list.get('results')]
|
||
self.assert_event_emitted(
|
||
'edx.team.deleted',
|
||
team_id=self.solar_team.team_id,
|
||
)
|
||
self.assert_event_emitted(
|
||
'edx.team.learner_removed',
|
||
team_id=self.solar_team.team_id,
|
||
remove_method='team_deleted',
|
||
user_id=self.users['student_enrolled'].id
|
||
)
|
||
|
||
@ddt.data(
|
||
('student_unenrolled', 403),
|
||
('student_enrolled', 403),
|
||
)
|
||
@ddt.unpack
|
||
def test_access_forbidden(self, user, status):
|
||
team_list = self.get_teams_list(user='course_staff', expected_status=200)
|
||
previous_count = team_list['count']
|
||
assert self.solar_team.team_id in [result['id'] for result in team_list.get('results')]
|
||
self.delete_team(self.solar_team.team_id, status, user=user)
|
||
|
||
team_list = self.get_teams_list(user='course_staff', expected_status=200)
|
||
assert team_list['count'] == previous_count
|
||
assert self.solar_team.team_id in [result['id'] for result in team_list.get('results')]
|
||
|
||
@ddt.data(
|
||
(None, 401),
|
||
('student_inactive', 401),
|
||
)
|
||
@ddt.unpack
|
||
def test_access_unauthorized(self, user, status):
|
||
self.delete_team(self.solar_team.team_id, status, user=user)
|
||
|
||
def test_does_not_exist(self):
|
||
self.delete_team('nonexistent', 404)
|
||
|
||
def test_memberships_deleted(self):
|
||
assert CourseTeamMembership.objects.filter(team=self.solar_team).count() == 1
|
||
self.delete_team(self.solar_team.team_id, 204, user='staff')
|
||
self.assert_event_emitted(
|
||
'edx.team.deleted',
|
||
team_id=self.solar_team.team_id,
|
||
)
|
||
self.assert_event_emitted(
|
||
'edx.team.learner_removed',
|
||
team_id=self.solar_team.team_id,
|
||
remove_method='team_deleted',
|
||
user_id=self.users['student_enrolled'].id
|
||
)
|
||
assert CourseTeamMembership.objects.filter(team=self.solar_team).count() == 0
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_unenrolled', 403),
|
||
('student_enrolled', 404),
|
||
('student_masters_not_on_team', 403),
|
||
('student_masters', 403),
|
||
('staff', 204)
|
||
)
|
||
def test_organization_protection_status(self, requesting_user, expected_status):
|
||
"""
|
||
As different users, try to delete the masters-only team.
|
||
Only staff should be able to delete this team, and people outside the bubble shouldn't be able to
|
||
tell that it even exists.
|
||
"""
|
||
self.delete_team(
|
||
self.masters_only_team.team_id,
|
||
expected_status,
|
||
user=requesting_user
|
||
)
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_unenrolled', 403),
|
||
('student_enrolled', 404),
|
||
('student_on_team_1_private_set_1', 403),
|
||
('student_on_team_2_private_set_1', 404),
|
||
('staff', 204)
|
||
)
|
||
def test_teamset_type(self, requesting_user, expected_status):
|
||
"""
|
||
As different users, try to delete a private_managed team
|
||
Only staff should be able to delete a private_managed team, and only they and users enrolled in that
|
||
team should even be able to tell that it exists.
|
||
"""
|
||
self.delete_team(
|
||
self.team_1_in_private_teamset_1.team_id,
|
||
expected_status,
|
||
user=requesting_user
|
||
)
|
||
|
||
|
||
@ddt.ddt
|
||
class TestUpdateTeamAPI(EventTestMixin, TeamAPITestCase):
|
||
"""Test cases for the team update endpoint."""
|
||
|
||
def setUp(self): # pylint: disable=arguments-differ
|
||
super().setUp('lms.djangoapps.teams.utils.tracker')
|
||
|
||
@ddt.data(
|
||
(None, 401),
|
||
('student_inactive', 401),
|
||
('student_unenrolled', 403),
|
||
('student_enrolled', 403),
|
||
('staff', 200),
|
||
('course_staff', 200),
|
||
('community_ta', 200),
|
||
)
|
||
@ddt.unpack
|
||
def test_access(self, user, status):
|
||
prev_name = self.solar_team.name
|
||
team = self.patch_team_detail(self.solar_team.team_id, status, {'name': 'foo'}, user=user)
|
||
if status == 200:
|
||
assert team['name'] == 'foo'
|
||
self.assert_event_emitted(
|
||
'edx.team.changed',
|
||
team_id=self.solar_team.team_id,
|
||
truncated=[],
|
||
field='name',
|
||
old=prev_name,
|
||
new='foo'
|
||
)
|
||
|
||
@ddt.data(
|
||
(None, 401),
|
||
('student_inactive', 401),
|
||
('student_unenrolled', 404),
|
||
('student_enrolled', 404),
|
||
('staff', 404),
|
||
('course_staff', 404),
|
||
('community_ta', 404),
|
||
)
|
||
@ddt.unpack
|
||
def test_access_bad_id(self, user, status):
|
||
self.patch_team_detail("no_such_team", status, {'name': 'foo'}, user=user)
|
||
|
||
@ddt.data(
|
||
('id', 'foobar'),
|
||
('description', ''),
|
||
('country', 'no_such_country'),
|
||
('language', 'no_such_language')
|
||
)
|
||
@ddt.unpack
|
||
def test_bad_requests(self, key, value):
|
||
self.patch_team_detail(self.solar_team.team_id, 400, {key: value}, user='staff')
|
||
|
||
@ddt.data(('country', 'US'), ('language', 'en'), ('foo', 'bar'))
|
||
@ddt.unpack
|
||
def test_good_requests(self, key, value):
|
||
if hasattr(self.solar_team, key):
|
||
prev_value = getattr(self.solar_team, key)
|
||
|
||
self.patch_team_detail(self.solar_team.team_id, 200, {key: value}, user='staff')
|
||
|
||
if hasattr(self.solar_team, key):
|
||
self.assert_event_emitted(
|
||
'edx.team.changed',
|
||
team_id=self.solar_team.team_id,
|
||
truncated=[],
|
||
field=key,
|
||
old=prev_value,
|
||
new=value
|
||
)
|
||
|
||
def test_does_not_exist(self):
|
||
self.patch_team_detail('no_such_team', 404, user='staff')
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_unenrolled', 403),
|
||
('student_enrolled', 404),
|
||
('student_masters_not_on_team', 403),
|
||
('student_masters', 403),
|
||
('staff', 200)
|
||
)
|
||
def test_organization_protection_status(self, requesting_user, expected_status):
|
||
"""
|
||
As different users, try to modify the masters-only team.
|
||
Only staff should be able to modify this team, and people outside the bubble shouldn't be able to
|
||
tell that it even exists.
|
||
"""
|
||
team = self.patch_team_detail(
|
||
self.masters_only_team.team_id,
|
||
expected_status,
|
||
{'name': 'foo'},
|
||
user=requesting_user
|
||
)
|
||
if expected_status == 200:
|
||
assert team['name'] == 'foo'
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_unenrolled', 403),
|
||
('student_enrolled', 404),
|
||
('student_on_team_1_private_set_1', 403),
|
||
('student_on_team_2_private_set_1', 404),
|
||
('staff', 200)
|
||
)
|
||
def test_teamset_type(self, requesting_user, expected_status):
|
||
"""
|
||
As different users, try to modify a private_managed team
|
||
Only staff should be able to modify a private_managed team, and only they and users enrolled in that
|
||
team should even be able to tell that it exists.
|
||
"""
|
||
team = self.patch_team_detail(
|
||
self.team_1_in_private_teamset_1.team_id,
|
||
expected_status,
|
||
{'name': 'foo'},
|
||
user=requesting_user
|
||
)
|
||
if expected_status == 200:
|
||
assert team['name'] == 'foo'
|
||
|
||
|
||
@patch.dict(settings.FEATURES, {'ENABLE_ORA_TEAM_SUBMISSIONS': True})
|
||
@ddt.ddt
|
||
class TestTeamAssignmentsView(TeamAPITestCase):
|
||
""" Tests for the TeamAssignmentsView """
|
||
|
||
@classmethod
|
||
def setUpClass(cls):
|
||
""" Create an openassessment block for testing """
|
||
super().setUpClass()
|
||
|
||
course = cls.test_course_1
|
||
teamset_id = cls.solar_team.topic_id
|
||
other_teamset_id = cls.wind_team.topic_id
|
||
|
||
section = ItemFactory.create(
|
||
parent=course,
|
||
category='chapter',
|
||
display_name='Test Section'
|
||
)
|
||
subsection = ItemFactory.create(
|
||
parent=section,
|
||
category="sequential"
|
||
)
|
||
unit_1 = ItemFactory.create(
|
||
parent=subsection,
|
||
category="vertical"
|
||
)
|
||
open_assessment = ItemFactory.create(
|
||
parent=unit_1,
|
||
category="openassessment",
|
||
teams_enabled=True,
|
||
selected_teamset_id=teamset_id
|
||
)
|
||
unit_2 = ItemFactory.create(
|
||
parent=subsection,
|
||
category="vertical"
|
||
)
|
||
off_team_open_assessment = ItemFactory.create( # pylint: disable=unused-variable
|
||
parent=unit_2,
|
||
category="openassessment",
|
||
teams_enabled=True,
|
||
selected_teamset_id=other_teamset_id
|
||
)
|
||
|
||
cls.team_assignments = [open_assessment]
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
(None, 401),
|
||
('student_inactive', 401),
|
||
('student_unenrolled', 403),
|
||
('student_on_team_2_private_set_1', 404),
|
||
('student_enrolled', 200),
|
||
('staff', 200),
|
||
('course_staff', 200),
|
||
('community_ta', 200),
|
||
)
|
||
def test_get_assignments(self, user, expected_status):
|
||
# Given a course with team-enabled open responses
|
||
team_id = self.solar_team.team_id
|
||
|
||
# When I get the assignments for a team
|
||
assignments = self.get_team_assignments(team_id, expected_status, user=user)
|
||
|
||
if expected_status == 200:
|
||
# I successful, I get back the assignments for a team
|
||
assert len(assignments) == len(self.team_assignments)
|
||
|
||
# ... with the right data structure
|
||
for assignment in assignments:
|
||
assert 'display_name' in assignment.keys()
|
||
assert 'location' in assignment.keys()
|
||
|
||
def test_get_assignments_bad_team(self):
|
||
# Given a bad team is supplied
|
||
user = 'student_enrolled'
|
||
team_id = 'bogus-team'
|
||
|
||
# When I run the query, I get back a 404 error
|
||
expected_status = 404
|
||
self.get_team_assignments(team_id, expected_status, user=user)
|
||
|
||
@patch.dict(settings.FEATURES, {'ENABLE_ORA_TEAM_SUBMISSIONS': False})
|
||
def test_get_assignments_feature_not_enabled(self):
|
||
# Given the team submissions feature is not enabled
|
||
user = 'student_enrolled'
|
||
team_id = self.solar_team.team_id
|
||
|
||
# When I try to get assignments
|
||
# Then I get back a 503 error
|
||
expected_status = 503
|
||
self.get_team_assignments(team_id, expected_status, user=user)
|
||
|
||
|
||
@ddt.ddt
|
||
class TestListTopicsAPI(TeamAPITestCase):
|
||
"""Test cases for the topic listing endpoint."""
|
||
|
||
@ddt.data(
|
||
(None, 401, None),
|
||
('student_inactive', 401, None),
|
||
('student_unenrolled', 403, None),
|
||
('student_enrolled', 200, 4),
|
||
('staff', 200, 7),
|
||
('course_staff', 200, 7),
|
||
('community_ta', 200, 4),
|
||
)
|
||
@ddt.unpack
|
||
def test_access(self, user, status, expected_topics_count):
|
||
topics = self.get_topics_list(status, {'course_id': str(self.test_course_1.id)}, user=user)
|
||
if status == 200:
|
||
assert topics['count'] == expected_topics_count
|
||
|
||
@ddt.data('A+BOGUS+COURSE', 'A/BOGUS/COURSE')
|
||
def test_invalid_course_key(self, course_id):
|
||
self.get_topics_list(404, {'course_id': course_id})
|
||
|
||
def test_without_course_id(self):
|
||
self.get_topics_list(400)
|
||
|
||
@ddt.data(
|
||
(None, 200, ['Coal Power', 'Nuclear Power', 'Sólar power', 'Wind Power'], 'name'),
|
||
('name', 200, ['Coal Power', 'Nuclear Power', 'Sólar power', 'Wind Power'], 'name'),
|
||
# Note that "Nuclear Power" will have 2 teams. "Coal Power" "Wind Power" and "Solar Power"
|
||
# all have 1 team. The secondary sort is alphabetical by name.
|
||
('team_count', 200, ['Nuclear Power', 'Coal Power', 'Sólar power', 'Wind Power'], 'team_count'),
|
||
('no_such_field', 400, [], None),
|
||
)
|
||
@ddt.unpack
|
||
def test_order_by(self, field, status, names, expected_ordering):
|
||
with skip_signal(
|
||
post_save,
|
||
receiver=course_team_post_save_callback,
|
||
sender=CourseTeam,
|
||
dispatch_uid='teams.signals.course_team_post_save_callback'
|
||
):
|
||
# Add a team to "Nuclear Power", so it has two teams
|
||
CourseTeamFactory.create(
|
||
name='Nuclear Team 1', course_id=self.test_course_1.id, topic_id='topic_2'
|
||
)
|
||
# Add a team to "Coal Power", so it has one team, same as "Wind" and "Solar"
|
||
CourseTeamFactory.create(
|
||
name='Coal Team 1', course_id=self.test_course_1.id, topic_id='topic_3'
|
||
)
|
||
data = {'course_id': str(self.test_course_1.id)}
|
||
if field:
|
||
data['order_by'] = field
|
||
topics = self.get_topics_list(status, data, user='student_enrolled')
|
||
if status == 200:
|
||
assert names == [topic['name'] for topic in topics['results']]
|
||
assert topics['sort_order'] == expected_ordering
|
||
|
||
def test_order_by_team_count_secondary(self):
|
||
"""
|
||
Ensure that the secondary sort (alphabetical) when primary sort is team_count
|
||
works across pagination boundaries.
|
||
"""
|
||
# All teams have one teamset, except for Coal Power, topic_3
|
||
with skip_signal(
|
||
post_save,
|
||
receiver=course_team_post_save_callback,
|
||
sender=CourseTeam,
|
||
dispatch_uid='teams.signals.course_team_post_save_callback'
|
||
):
|
||
# Add two wind teams, a solar team and a coal team, to bring the totals to
|
||
# Wind: 3 Solar: 2 Coal: 1, Nuclear: 1
|
||
CourseTeamFactory.create(
|
||
name='Wind Team 1', course_id=self.test_course_1.id, topic_id='topic_1'
|
||
)
|
||
CourseTeamFactory.create(
|
||
name='Wind Team 2', course_id=self.test_course_1.id, topic_id='topic_1'
|
||
)
|
||
CourseTeamFactory.create(
|
||
name='Solar Team 1', course_id=self.test_course_1.id, topic_id='topic_0'
|
||
)
|
||
CourseTeamFactory.create(
|
||
name='Coal Team 1', course_id=self.test_course_1.id, topic_id='topic_3'
|
||
)
|
||
|
||
# Wind power has the most teams, followed by Solar
|
||
topics = self.get_topics_list(
|
||
data={
|
||
'course_id': str(self.test_course_1.id),
|
||
'page_size': 2,
|
||
'page': 1,
|
||
'order_by': 'team_count'
|
||
},
|
||
user='student_enrolled'
|
||
)
|
||
assert ['Wind Power', 'Sólar power'] == [topic['name'] for topic in topics['results']]
|
||
|
||
# Coal and Nuclear are tied, so they are alphabetically sorted.
|
||
topics = self.get_topics_list(
|
||
data={
|
||
'course_id': str(self.test_course_1.id),
|
||
'page_size': 2,
|
||
'page': 2,
|
||
'order_by': 'team_count'
|
||
},
|
||
user='student_enrolled'
|
||
)
|
||
assert ['Coal Power', 'Nuclear Power'] == [topic['name'] for topic in topics['results']]
|
||
|
||
def test_pagination(self):
|
||
response = self.get_topics_list(
|
||
data={
|
||
'course_id': str(self.test_course_1.id),
|
||
'page_size': 2,
|
||
},
|
||
user='student_enrolled'
|
||
)
|
||
|
||
assert 2 == len(response['results'])
|
||
assert 'next' in response
|
||
assert 'previous' in response
|
||
assert response['previous'] is None
|
||
assert response['next'] is not None
|
||
|
||
def test_default_ordering(self):
|
||
response = self.get_topics_list(data={'course_id': str(self.test_course_1.id)})
|
||
assert response['sort_order'] == 'name'
|
||
|
||
def test_team_count(self):
|
||
"""Test that team_count is included for each topic"""
|
||
response = self.get_topics_list(
|
||
data={'course_id': str(self.test_course_1.id)},
|
||
user='student_enrolled'
|
||
)
|
||
for topic in response['results']:
|
||
assert 'team_count' in topic
|
||
if topic['id'] in ('topic_0', 'topic_1', 'topic_2'):
|
||
assert topic['team_count'] == 1
|
||
else:
|
||
assert topic['team_count'] == 0
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_enrolled', 0),
|
||
('student_on_team_1_private_set_1', 1),
|
||
('student_on_team_2_private_set_1', 1),
|
||
('student_masters', 0),
|
||
('staff', 3)
|
||
)
|
||
def test_teamset_type(self, requesting_user, expected_private_teamsets):
|
||
"""
|
||
As different users, request course_1's list of topics, and see what private_managed teamsets are returned
|
||
|
||
Staff should be able to see all teamsets, and anyone enrolled in a private teamset should see that and
|
||
only that teamset
|
||
"""
|
||
topics = self.get_topics_list(
|
||
data={'course_id': str(self.test_course_1.id)},
|
||
user=requesting_user
|
||
)
|
||
private_teamsets_returned = [
|
||
topic['name'] for topic in topics['results'] if topic['type'] == 'private_managed'
|
||
]
|
||
assert len(private_teamsets_returned) == expected_private_teamsets
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_on_team_1_private_set_1', 1),
|
||
('student_on_team_2_private_set_1', 1),
|
||
('staff', 2)
|
||
)
|
||
def test_private_teamset_team_count(self, requesting_user, expected_team_count):
|
||
"""
|
||
Students should only see teams they are members of in private team-sets
|
||
"""
|
||
topics = self.get_topics_list(
|
||
data={'course_id': str(self.test_course_1.id)},
|
||
user=requesting_user
|
||
)
|
||
private_teamset_1 = [topic for topic in topics['results'] if topic['name'] == 'private_topic_1_name'][0]
|
||
assert private_teamset_1['team_count'] == expected_team_count
|
||
|
||
|
||
@ddt.ddt
|
||
class TestDetailTopicAPI(TeamAPITestCase):
|
||
"""Test cases for the topic detail endpoint."""
|
||
|
||
@ddt.data(
|
||
(None, 401),
|
||
('student_inactive', 401),
|
||
('student_unenrolled', 403),
|
||
('student_enrolled', 200),
|
||
('staff', 200),
|
||
('course_staff', 200),
|
||
('community_ta', 200),
|
||
)
|
||
@ddt.unpack
|
||
def test_access(self, user, status):
|
||
topic = self.get_topic_detail('topic_0', self.test_course_1.id, status, user=user)
|
||
if status == 200:
|
||
for field in ('id', 'name', 'description'):
|
||
assert field in topic
|
||
|
||
@ddt.data('A+BOGUS+COURSE', 'A/BOGUS/COURSE')
|
||
def test_invalid_course_id(self, course_id):
|
||
self.get_topic_detail('topic_0', course_id, 404)
|
||
|
||
def test_invalid_topic_id(self):
|
||
self.get_topic_detail('no_such_topic', self.test_course_1.id, 404)
|
||
|
||
def test_topic_detail_with_caps_and_dot_in_id(self):
|
||
self.get_topic_detail('Topic_6.5', self.test_course_2.id, user='student_enrolled_public_profile')
|
||
|
||
def test_team_count(self):
|
||
"""Test that team_count is included with a topic"""
|
||
topic = self.get_topic_detail(topic_id='topic_0', course_id=self.test_course_1.id)
|
||
assert topic['team_count'] == 1
|
||
topic = self.get_topic_detail(topic_id='topic_1', course_id=self.test_course_1.id)
|
||
assert topic['team_count'] == 1
|
||
topic = self.get_topic_detail(topic_id='topic_2', course_id=self.test_course_1.id)
|
||
assert topic['team_count'] == 1
|
||
topic = self.get_topic_detail(topic_id='topic_3', course_id=self.test_course_1.id)
|
||
assert topic['team_count'] == 0
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_enrolled', 404, None),
|
||
('student_on_team_1_private_set_1', 200, 1),
|
||
('student_on_team_2_private_set_1', 200, 1),
|
||
('student_masters', 404, None),
|
||
('staff', 200, 2)
|
||
)
|
||
def test_teamset_type(self, requesting_user, expected_status, expected_team_count):
|
||
"""
|
||
As different users, request info about a private_managed team.
|
||
Staff should be able to see all teamsets, and someone enrolled in a private_managed teamset
|
||
should be able to see that and only that teamset. As shown in `test_invalid_topic_id`,
|
||
nonexistant topics 404, and if someone doesn't have access to a private_managed teamset, as far as they know
|
||
the teamset does not exist.
|
||
"""
|
||
topic = self.get_topic_detail(
|
||
topic_id='private_topic_1_id',
|
||
course_id=self.test_course_1.id,
|
||
expected_status=expected_status,
|
||
user=requesting_user
|
||
)
|
||
if expected_status == 200:
|
||
assert topic['name'] == 'private_topic_1_name'
|
||
assert topic['team_count'] == expected_team_count
|
||
|
||
|
||
@ddt.ddt
|
||
class TestListMembershipAPI(TeamAPITestCase):
|
||
"""Test cases for the membership list endpoint."""
|
||
|
||
@ddt.data(
|
||
(None, 401),
|
||
('student_inactive', 401),
|
||
('student_unenrolled', 404),
|
||
('student_enrolled', 200),
|
||
('student_enrolled_both_courses_other_team', 200),
|
||
('staff', 200),
|
||
('course_staff', 200),
|
||
('community_ta', 200),
|
||
)
|
||
@ddt.unpack
|
||
def test_access(self, user, status):
|
||
membership = self.get_membership_list(status, {'team_id': self.solar_team.team_id}, user=user)
|
||
if status == 200:
|
||
assert membership['count'] == 1
|
||
assert membership['results'][0]['user']['username'] == self.users['student_enrolled'].username
|
||
|
||
@ddt.data(
|
||
(None, 401, False),
|
||
('student_inactive', 401, False),
|
||
('student_unenrolled', 200, False),
|
||
('student_enrolled', 200, True),
|
||
('student_enrolled_both_courses_other_team', 200, True),
|
||
('staff', 200, True),
|
||
('course_staff', 200, True),
|
||
('community_ta', 200, True),
|
||
)
|
||
@ddt.unpack
|
||
def test_access_by_username(self, user, status, has_content):
|
||
membership = self.get_membership_list(status, {'username': self.users['student_enrolled'].username}, user=user)
|
||
if status == 200:
|
||
if has_content:
|
||
assert membership['count'] == 1
|
||
assert membership['results'][0]['team']['team_id'] == self.solar_team.team_id
|
||
else:
|
||
assert membership['count'] == 0
|
||
|
||
@ddt.data(
|
||
('student_masters', True),
|
||
('student_masters_not_on_team', True),
|
||
('student_unenrolled', False),
|
||
('student_enrolled', True),
|
||
('student_enrolled_both_courses_other_team', True),
|
||
('staff', True),
|
||
)
|
||
@ddt.unpack
|
||
def test_access_by_username_organization_protected(self, user, can_see_bubble_team):
|
||
"""
|
||
As different users, request team membership info for student_masters
|
||
Only staff, and users who are within the bubble should be able to see a bubble user's team
|
||
memberships. Non-bubble users shouldn't be able to tell that student_masters exists.
|
||
(Nonexistant users still return 200, just with no data.)
|
||
|
||
TODO: Only the oragnization_protected users (student_masters, student_masters_not_on_team)
|
||
and staff should be able to see student_masters
|
||
"""
|
||
membership = self.get_membership_list(200, {'username': 'student_masters'}, user=user)
|
||
if can_see_bubble_team:
|
||
assert membership['count'] == 1
|
||
assert membership['results'][0]['team']['team_id'] == self.masters_only_team.team_id
|
||
else:
|
||
assert membership['count'] == 0
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_on_team_1_private_set_1', True, True),
|
||
('student_unenrolled', False, False),
|
||
('student_enrolled', True, True),
|
||
('student_on_team_2_private_set_1', True, True),
|
||
('student_masters', True, True),
|
||
('staff', True, True)
|
||
)
|
||
def test_access_by_username_private_teamset(self, user, can_see_any_teams, can_see_private_team):
|
||
"""
|
||
Add student_on_team_1_private_set_1 to masters_only_team.
|
||
Then, as different users, request team membership info for student_on_team_1_private_set_1.
|
||
Anyone in the organization_protected bubble should be able to see the masters_only membership,
|
||
but only staff and users in team_1_private_set_1 ahould be able to see that membership.
|
||
|
||
TODO: student_enrolled shouldn't see any teams as he is outside the bubble.
|
||
student_masters and sot2ps1 should only see masters_only team.
|
||
"""
|
||
self.masters_only_team.add_user(self.users['student_on_team_1_private_set_1'])
|
||
memberships = self.get_membership_list(200, {'username': 'student_on_team_1_private_set_1'}, user=user)
|
||
team_ids = [membership['team']['team_id'] for membership in memberships['results']]
|
||
if can_see_private_team:
|
||
assert len(team_ids) == 2
|
||
assert self.team_1_in_private_teamset_1.team_id in team_ids
|
||
assert self.masters_only_team.team_id in team_ids
|
||
elif can_see_any_teams:
|
||
assert len(team_ids) == 1
|
||
assert self.masters_only_team.team_id in team_ids
|
||
else:
|
||
assert len(team_ids) == 0
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_on_team_1_private_set_1', 200),
|
||
('student_unenrolled', 404),
|
||
('student_enrolled', 403),
|
||
('student_on_team_2_private_set_1', 403),
|
||
('student_masters', 403),
|
||
('staff', 200)
|
||
)
|
||
def test_access_by_team_private_teamset(self, user, expected_response):
|
||
"""
|
||
As different users, request membership info for team_1_in_private_teamset_1.
|
||
Only staff or users enrolled in a private_managed team should be able to tell that the team exists.
|
||
(a bad team_id returns a 404 currently)
|
||
|
||
TODO: No data is returned that shouldn't be, but the 403 that the users get tells them that a team
|
||
with the given id does in fact exist. This should be changed to be a 404.
|
||
"""
|
||
memberships = self.get_membership_list(
|
||
expected_response,
|
||
{'team_id': self.team_1_in_private_teamset_1.team_id},
|
||
user=user
|
||
)
|
||
if expected_response == 200:
|
||
users = [membership['user']['username'] for membership in memberships['results']]
|
||
assert users == ['student_on_team_1_private_set_1']
|
||
|
||
@ddt.data(
|
||
('student_enrolled_both_courses_other_team', 'TestX/TS101/Test_Course', 200, 'Nuclear Team'),
|
||
('student_enrolled_both_courses_other_team', 'MIT/6.002x/Circuits', 200, 'Another Team'),
|
||
('student_enrolled', 'TestX/TS101/Test_Course', 200, 'Sólar team'),
|
||
('student_enrolled', 'MIT/6.002x/Circuits', 400, ''),
|
||
)
|
||
@ddt.unpack
|
||
def test_course_filter_with_username(self, user, course_id, status, team_name):
|
||
membership = self.get_membership_list(
|
||
status,
|
||
{
|
||
'username': self.users[user],
|
||
'course_id': course_id
|
||
},
|
||
user=user
|
||
)
|
||
if status == 200:
|
||
assert membership['count'] == 1
|
||
assert membership['results'][0]['team']['team_id'] == self.test_team_name_id_map[team_name].team_id
|
||
|
||
@ddt.data(
|
||
('TestX/TS101/Test_Course', 200),
|
||
('MIT/6.002x/Circuits', 400),
|
||
)
|
||
@ddt.unpack
|
||
def test_course_filter_with_team_id(self, course_id, status):
|
||
membership = self.get_membership_list(status, {'team_id': self.solar_team.team_id, 'course_id': course_id})
|
||
if status == 200:
|
||
assert membership['count'] == 1
|
||
assert membership['results'][0]['team']['team_id'] == self.solar_team.team_id
|
||
|
||
def test_nonexistent_user(self):
|
||
response = self.get_membership_list(200, {'username': 'this-user-will-not-exist-&&&&#!^'})
|
||
assert response['count'] == 0
|
||
|
||
def test_bad_course_id(self):
|
||
self.get_membership_list(404, {'course_id': 'no_such_course'})
|
||
|
||
def test_no_username_or_team_id(self):
|
||
self.get_membership_list(400, {})
|
||
|
||
def test_bad_team_id(self):
|
||
self.get_membership_list(404, {'team_id': 'no_such_team'})
|
||
|
||
def test_expand_private_user(self):
|
||
# Use the default user which is already private because to year_of_birth is set
|
||
result = self.get_membership_list(200, {'team_id': self.solar_team.team_id, 'expand': 'user'})
|
||
self.verify_expanded_private_user(result['results'][0]['user'])
|
||
|
||
def test_expand_public_user(self):
|
||
result = self.get_membership_list(
|
||
200,
|
||
{'team_id': self.public_profile_team.team_id, 'expand': 'user'},
|
||
user='student_enrolled_public_profile'
|
||
)
|
||
self.verify_expanded_public_user(result['results'][0]['user'])
|
||
|
||
def test_expand_team(self):
|
||
result = self.get_membership_list(200, {'team_id': self.solar_team.team_id, 'expand': 'team'})
|
||
self.verify_expanded_team(result['results'][0]['team'])
|
||
|
||
@ddt.data(False, True)
|
||
def test_filter_teamset(self, filter_username):
|
||
other_username = self.create_and_enroll_student()
|
||
self.solar_team.add_user(self.users[other_username])
|
||
filters = {
|
||
'teamset_id': self.solar_team.topic_id,
|
||
'course_id': str(self.test_course_1.id)
|
||
}
|
||
if filter_username:
|
||
filters['username'] = other_username
|
||
|
||
result = self.get_membership_list(200, filters)
|
||
assert result['count'] == (1 if filter_username else 2)
|
||
usernames = {enrollment['user']['username'] for enrollment in result['results']}
|
||
assert other_username in usernames
|
||
if not filter_username:
|
||
assert 'student_enrolled' in usernames
|
||
|
||
def test_filter_teamset_team_id(self):
|
||
# team_id and teamset_id are mutually exclusive
|
||
self.get_membership_list(
|
||
400,
|
||
{
|
||
'team_id': self.solar_team.team_id,
|
||
'teamset_id': 'topic_0',
|
||
'course_id': 'TestX/TS101/Non_Existent_Course'
|
||
}
|
||
)
|
||
|
||
def test_filter_teamset_no_course(self):
|
||
self.get_membership_list(400, {'teamset_id': 'topic_0'})
|
||
|
||
def test_filter_teamset_not_enrolled_in_course(self):
|
||
self.get_membership_list(
|
||
404,
|
||
{
|
||
'teamset_id': 'topic_0',
|
||
'course_id': str(self.test_course_1.id)
|
||
},
|
||
user='student_unenrolled'
|
||
)
|
||
|
||
def test_filter_teamset_course_nonexistant(self):
|
||
self.get_membership_list(404, {'teamset_id': 'topic_0', 'course_id': 'TestX/TS101/Non_Existent_Course'})
|
||
|
||
def test_filter_teamset_teamset_nonexistant(self):
|
||
self.get_membership_list(404, {'teamset_id': 'nonexistant', 'course_id': str(self.test_course_1.id)})
|
||
|
||
def test_filter_teamset_enrolled_in_course_but_no_team_access(self):
|
||
# The requesting user is enrolled in the course, but the requested team is oraganization_protected and
|
||
# the requesting user is outside of the bubble
|
||
self.get_membership_list(
|
||
404,
|
||
{
|
||
'teamset_id': 'private_topic_1_id',
|
||
'course_id': str(self.test_course_1.id),
|
||
'username': 'student_on_team_1_private_set_1'
|
||
}
|
||
)
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_enrolled', 404, None),
|
||
('student_on_team_1_private_set_1', 200, {'student_on_team_1_private_set_1'}),
|
||
('student_on_team_2_private_set_1', 200, {'student_on_team_2_private_set_1'}),
|
||
('student_masters', 404, None),
|
||
('staff', 200, {'student_on_team_1_private_set_1', 'student_on_team_2_private_set_1'})
|
||
)
|
||
def test_access_filter_teamset__private_teamset(self, user, expected_response, expected_users):
|
||
memberships = self.get_membership_list(
|
||
expected_response,
|
||
{
|
||
'teamset_id': 'private_topic_1_id',
|
||
'course_id': str(self.test_course_1.id),
|
||
},
|
||
user=user
|
||
)
|
||
if expected_response == 200:
|
||
returned_users = {membership['user']['username'] for membership in memberships['results']}
|
||
assert returned_users == expected_users
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_enrolled', 404),
|
||
('student_on_team_1_private_set_1', 404),
|
||
('student_on_team_2_private_set_1', 404),
|
||
('student_masters', 404),
|
||
('staff', 200)
|
||
)
|
||
def test_access_filter_teamset__private_teamset__no_teams(self, user, expected_response):
|
||
"""
|
||
private_topic_no_teams has no teams in it, but staff should still get a 200 when
|
||
requesting teamset memberships
|
||
"""
|
||
self.get_membership_list(
|
||
expected_response,
|
||
{
|
||
'teamset_id': 'private_topic_no_teams',
|
||
'course_id': str(self.test_course_1.id),
|
||
},
|
||
user=user
|
||
)
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_unenrolled', 404, {}),
|
||
('student_enrolled_not_on_team', 200, {'student_enrolled'}),
|
||
('student_enrolled', 200, {'student_enrolled'}),
|
||
('student_masters', 200, {'student_masters'}),
|
||
('staff', 200, {'student_enrolled', 'student_masters'})
|
||
)
|
||
def test_access_filter_teamset__open_teamset(self, user, expected_response, expected_usernames):
|
||
# topic_3 has no teams
|
||
assert not CourseTeam.objects.filter(topic_id='topic_3').exists()
|
||
memberships = self.get_membership_list(
|
||
expected_response,
|
||
{
|
||
'teamset_id': 'topic_3',
|
||
'course_id': str(self.test_course_1.id),
|
||
},
|
||
user=user
|
||
)
|
||
if expected_response == 200:
|
||
assert memberships['count'] == 0
|
||
|
||
# topic_0 has teams
|
||
assert CourseTeam.objects.filter(topic_id='topic_0').exists()
|
||
memberships = self.get_membership_list(
|
||
expected_response,
|
||
{
|
||
'teamset_id': 'topic_0',
|
||
'course_id': str(self.test_course_1.id),
|
||
},
|
||
user=user
|
||
)
|
||
if expected_response == 200:
|
||
returned_users = {membership['user']['username'] for membership in memberships['results']}
|
||
assert returned_users == expected_usernames
|
||
|
||
|
||
@ddt.ddt
|
||
class TestCreateMembershipAPI(EventTestMixin, TeamAPITestCase):
|
||
"""Test cases for the membership creation endpoint."""
|
||
|
||
def setUp(self): # pylint: disable=arguments-differ
|
||
super().setUp('lms.djangoapps.teams.utils.tracker')
|
||
|
||
@ddt.data(
|
||
(None, 401),
|
||
('student_inactive', 401),
|
||
('student_unenrolled', 404),
|
||
('student_enrolled_not_on_team', 200),
|
||
('student_enrolled', 404),
|
||
('student_enrolled_both_courses_other_team', 404),
|
||
('staff', 200),
|
||
('course_staff', 200),
|
||
('community_ta', 200),
|
||
)
|
||
@ddt.unpack
|
||
def test_access(self, user, status):
|
||
membership = self.post_create_membership(
|
||
status,
|
||
self.build_membership_data('student_enrolled_not_on_team', self.solar_team),
|
||
user=user
|
||
)
|
||
if status == 200:
|
||
assert membership['user']['username'] == self.users['student_enrolled_not_on_team'].username
|
||
assert membership['team']['team_id'] == self.solar_team.team_id
|
||
memberships = self.get_membership_list(200, {'team_id': self.solar_team.team_id})
|
||
assert memberships['count'] == 2
|
||
|
||
add_method = 'joined_from_team_view' if user == 'student_enrolled_not_on_team' else 'added_by_another_user'
|
||
|
||
self.assert_event_emitted(
|
||
'edx.team.learner_added',
|
||
team_id=self.solar_team.team_id,
|
||
user_id=self.users['student_enrolled_not_on_team'].id,
|
||
add_method=add_method
|
||
)
|
||
else:
|
||
self.assert_no_events_were_emitted()
|
||
|
||
def test_no_username(self):
|
||
response = self.post_create_membership(400, {'team_id': self.solar_team.team_id})
|
||
assert 'username' in json.loads(response.content.decode('utf-8'))['field_errors']
|
||
|
||
def test_no_team(self):
|
||
response = self.post_create_membership(400, {'username': self.users['student_enrolled_not_on_team'].username})
|
||
assert 'team_id' in json.loads(response.content.decode('utf-8'))['field_errors']
|
||
|
||
@ddt.data('staff', 'student_enrolled')
|
||
def test_bad_team(self, user):
|
||
self.post_create_membership(
|
||
404,
|
||
self.build_membership_data_raw(self.users['student_enrolled'].username, 'no_such_team'),
|
||
user=user
|
||
)
|
||
|
||
def test_bad_username(self):
|
||
self.post_create_membership(
|
||
404,
|
||
self.build_membership_data_raw('no_such_user', self.solar_team.team_id),
|
||
user='staff'
|
||
)
|
||
|
||
@patch('lms.djangoapps.teams.api.is_instructor_managed_team', return_value=True)
|
||
def test_staff_join_instructor_managed_team(self, *args): # pylint: disable=unused-argument
|
||
self.post_create_membership(
|
||
200,
|
||
self.build_membership_data_raw(self.users['staff'].username, self.solar_team.team_id),
|
||
user='staff'
|
||
)
|
||
|
||
@patch('lms.djangoapps.teams.api.is_instructor_managed_team', return_value=True)
|
||
def test_student_join_instructor_managed_team(self, *args): # pylint: disable=unused-argument
|
||
self.post_create_membership(
|
||
403,
|
||
self.build_membership_data_raw(self.users['student_enrolled_not_on_team'].username, self.solar_team.team_id)
|
||
)
|
||
|
||
@ddt.data(
|
||
('student_masters', 400, 'is already a member'),
|
||
('student_masters_not_on_team', 200, None),
|
||
('student_unenrolled', 404, None),
|
||
('student_enrolled', 404, None),
|
||
('student_enrolled_both_courses_other_team', 404, None),
|
||
('staff', 200, None),
|
||
)
|
||
@ddt.unpack
|
||
def test_join_organization_protected_team(self, user, expected_status, expected_message):
|
||
"""
|
||
As different users, attempt to join masters_only team.
|
||
Only staff or users within the organization_protected bubble should be able to join the team.
|
||
Anyone else should not be able to join or even tell that the team exists.
|
||
"""
|
||
response = self.post_create_membership(
|
||
expected_status,
|
||
self.build_membership_data_raw(self.users[user].username, self.masters_only_team.team_id),
|
||
user=user
|
||
)
|
||
if expected_message:
|
||
assert expected_message in json.loads(response.content.decode('utf-8'))['developer_message']
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_on_team_1_private_set_1', 403),
|
||
('student_unenrolled', 404),
|
||
('student_enrolled', 404),
|
||
('student_on_team_2_private_set_1', 404),
|
||
('student_masters', 404),
|
||
('staff', 200)
|
||
)
|
||
def test_student_join_private_managed_team(self, user, expected_status):
|
||
"""
|
||
As different users, attempt to join private_managed team.
|
||
Only staff should be able to add users to any managed teams.
|
||
Anyone else should not be able to join, and only student_on_team_1_private_set_1 should
|
||
be able to tell that the team exists at all.
|
||
(A nonexistant team results in a 404)
|
||
"""
|
||
self.post_create_membership(
|
||
expected_status,
|
||
self.build_membership_data_raw(self.users[user].username, self.team_1_in_private_teamset_1.team_id),
|
||
user=user
|
||
)
|
||
|
||
@ddt.data('student_enrolled', 'staff', 'course_staff')
|
||
def test_join_twice(self, user):
|
||
response = self.post_create_membership(
|
||
400,
|
||
self.build_membership_data('student_enrolled', self.solar_team),
|
||
user=user
|
||
)
|
||
assert 'already a member' in json.loads(response.content.decode('utf-8'))['developer_message']
|
||
|
||
def test_join_second_team_in_course(self):
|
||
"""
|
||
Behavior allows the same student to be enrolled in multiple teams, as long as they belong to different
|
||
topics (teamsets)
|
||
"""
|
||
self.post_create_membership(
|
||
200,
|
||
self.build_membership_data('student_enrolled_both_courses_other_team', self.solar_team),
|
||
user='student_enrolled_both_courses_other_team'
|
||
)
|
||
|
||
@ddt.data('staff', 'course_staff')
|
||
def test_not_enrolled_in_team_course(self, user):
|
||
response = self.post_create_membership(
|
||
400,
|
||
self.build_membership_data('student_unenrolled', self.solar_team),
|
||
user=user
|
||
)
|
||
assert 'not enrolled' in json.loads(response.content.decode('utf-8'))['developer_message']
|
||
|
||
def test_over_max_team_size_in_course_2(self):
|
||
response = self.post_create_membership(
|
||
400,
|
||
self.build_membership_data('student_enrolled_other_course_not_on_team', self.another_team),
|
||
user='student_enrolled_other_course_not_on_team'
|
||
)
|
||
assert 'full' in json.loads(response.content.decode('utf-8'))['developer_message']
|
||
|
||
|
||
@ddt.ddt
|
||
class TestDetailMembershipAPI(TeamAPITestCase):
|
||
"""Test cases for the membership detail endpoint."""
|
||
|
||
@ddt.data(
|
||
(None, 401),
|
||
('student_inactive', 401),
|
||
('student_unenrolled', 404),
|
||
('student_enrolled_not_on_team', 200),
|
||
('student_enrolled', 200),
|
||
('staff', 200),
|
||
('course_staff', 200),
|
||
('community_ta', 200),
|
||
)
|
||
@ddt.unpack
|
||
def test_access(self, user, status):
|
||
self.get_membership_detail(
|
||
self.solar_team.team_id,
|
||
self.users['student_enrolled'].username,
|
||
status,
|
||
user=user
|
||
)
|
||
|
||
def test_bad_team(self):
|
||
self.get_membership_detail('no_such_team', self.users['student_enrolled'].username, 404)
|
||
|
||
def test_bad_username(self):
|
||
self.get_membership_detail(self.solar_team.team_id, 'no_such_user', 404)
|
||
|
||
def test_no_membership(self):
|
||
self.get_membership_detail(
|
||
self.solar_team.team_id,
|
||
self.users['student_enrolled_not_on_team'].username,
|
||
404
|
||
)
|
||
|
||
def test_expand_private_user(self):
|
||
# Use the default user which is already private because to year_of_birth is set
|
||
result = self.get_membership_detail(
|
||
self.solar_team.team_id,
|
||
self.users['student_enrolled'].username,
|
||
200,
|
||
{'expand': 'user'}
|
||
)
|
||
self.verify_expanded_private_user(result['user'])
|
||
|
||
def test_expand_public_user(self):
|
||
result = self.get_membership_detail(
|
||
self.public_profile_team.team_id,
|
||
self.users['student_enrolled_public_profile'].username,
|
||
200,
|
||
{'expand': 'user'},
|
||
user='student_enrolled_public_profile'
|
||
)
|
||
self.verify_expanded_public_user(result['user'])
|
||
|
||
def test_expand_team(self):
|
||
result = self.get_membership_detail(
|
||
self.solar_team.team_id,
|
||
self.users['student_enrolled'].username,
|
||
200,
|
||
{'expand': 'team'}
|
||
)
|
||
self.verify_expanded_team(result['team'])
|
||
|
||
@ddt.data(
|
||
('student_masters', 200),
|
||
('student_masters_not_on_team', 200),
|
||
('student_unenrolled', 404),
|
||
('student_enrolled', 404),
|
||
('student_enrolled_both_courses_other_team', 404),
|
||
('staff', 200),
|
||
)
|
||
@ddt.unpack
|
||
def test_organization_protected(self, user, expected_status):
|
||
"""
|
||
Users should not be able to see memberships for users in a different bubble than them
|
||
"""
|
||
self.get_membership_detail(
|
||
self.masters_only_team.team_id,
|
||
self.users['student_masters'].username,
|
||
expected_status,
|
||
user=user
|
||
)
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_on_team_1_private_set_1', 200),
|
||
('student_unenrolled', 404),
|
||
('student_enrolled', 404),
|
||
('student_on_team_2_private_set_1', 404),
|
||
('staff', 200)
|
||
)
|
||
def test_private_managed_team(self, user, expected_status):
|
||
"""
|
||
Users should not be able to see memberships for users in private_managed
|
||
teams that they are not a member of
|
||
"""
|
||
self.get_membership_detail(
|
||
self.team_1_in_private_teamset_1.team_id,
|
||
self.users['student_on_team_1_private_set_1'].username,
|
||
expected_status,
|
||
user=user
|
||
)
|
||
|
||
def test_join_private_managed_teamset(self):
|
||
"""
|
||
A user who is not on a private team requests membership info about that team.
|
||
They are added to the team and then try again.
|
||
"""
|
||
self.get_membership_detail(
|
||
self.team_1_in_private_teamset_1.team_id,
|
||
self.users['student_on_team_1_private_set_1'].username,
|
||
404,
|
||
user='student_masters'
|
||
)
|
||
self.team_1_in_private_teamset_1.add_user(self.users['student_masters'])
|
||
self.get_membership_detail(
|
||
self.team_1_in_private_teamset_1.team_id,
|
||
self.users['student_on_team_1_private_set_1'].username,
|
||
200,
|
||
user='student_masters'
|
||
)
|
||
|
||
|
||
@ddt.ddt
|
||
class TestDeleteMembershipAPI(EventTestMixin, TeamAPITestCase):
|
||
"""Test cases for the membership deletion endpoint."""
|
||
|
||
def setUp(self): # pylint: disable=arguments-differ
|
||
super().setUp('lms.djangoapps.teams.utils.tracker')
|
||
|
||
@ddt.data(
|
||
(None, 401),
|
||
('student_inactive', 401),
|
||
('student_unenrolled', 404),
|
||
('student_enrolled_not_on_team', 404),
|
||
('student_enrolled', 204),
|
||
('staff', 204),
|
||
('course_staff', 204),
|
||
('community_ta', 204),
|
||
)
|
||
@ddt.unpack
|
||
def test_access(self, user, status):
|
||
self.delete_membership(
|
||
self.solar_team.team_id,
|
||
self.users['student_enrolled'].username,
|
||
status,
|
||
user=user
|
||
)
|
||
|
||
if status == 204:
|
||
self.assert_event_emitted(
|
||
'edx.team.learner_removed',
|
||
team_id=self.solar_team.team_id,
|
||
user_id=self.users['student_enrolled'].id,
|
||
remove_method='removed_by_admin'
|
||
)
|
||
else:
|
||
self.assert_no_events_were_emitted()
|
||
|
||
def test_leave_team(self):
|
||
"""
|
||
The key difference between this test and test_access above is that
|
||
removal via "Edit Membership" and "Leave Team" emit different events
|
||
despite hitting the same API endpoint, due to the 'admin' query string.
|
||
"""
|
||
url = reverse('team_membership_detail', args=[self.solar_team.team_id, self.users['student_enrolled'].username])
|
||
self.make_call(url, 204, 'delete', user='student_enrolled')
|
||
self.assert_event_emitted(
|
||
'edx.team.learner_removed',
|
||
team_id=self.solar_team.team_id,
|
||
user_id=self.users['student_enrolled'].id,
|
||
remove_method='self_removal'
|
||
)
|
||
|
||
def test_bad_team(self):
|
||
self.delete_membership('no_such_team', self.users['student_enrolled'].username, 404)
|
||
|
||
def test_bad_username(self):
|
||
self.delete_membership(self.solar_team.team_id, 'no_such_user', 404)
|
||
|
||
def test_missing_membership(self):
|
||
self.delete_membership(self.wind_team.team_id, self.users['student_enrolled'].username, 404)
|
||
|
||
@patch('lms.djangoapps.teams.api.is_instructor_managed_team', return_value=True)
|
||
def test_student_leave_instructor_managed_team(self, *args): # pylint: disable=unused-argument
|
||
self.delete_membership(
|
||
self.solar_team.team_id, self.users['student_enrolled'].username, 403, user='student_enrolled')
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_enrolled', 'student_masters', 404),
|
||
('student_enrolled', 'student_enrolled', 404),
|
||
('student_masters_not_on_team', 'student_masters', 404),
|
||
('student_masters_not_on_team', 'student_masters_not_on_team', 404),
|
||
('student_masters', 'student_masters', 204),
|
||
('staff', 'student_masters', 204),
|
||
('staff', 'staff', 404),
|
||
)
|
||
def test_organization_protection_status(self, user, user_to_remove, expected_status):
|
||
"""
|
||
As different users, attempt to remove themselves or studet_masters from masters_only team.
|
||
(only student_masters is actually on this team)
|
||
Only staff and the student_masters should be able to remove, and users outside of the
|
||
organization_protected bubble should not be able to tell that the team exists in
|
||
any way.
|
||
|
||
TODO: student_enrolled should not be able to tell that masters_only team exists, he should
|
||
get a 404 on both calls
|
||
"""
|
||
self.delete_membership(
|
||
self.masters_only_team.team_id,
|
||
self.users[user_to_remove].username,
|
||
expected_status,
|
||
user=user
|
||
)
|
||
|
||
@ddt.unpack
|
||
@ddt.data(
|
||
('student_enrolled', 'student_on_team_1_private_set_1', 404),
|
||
('student_enrolled', 'student_enrolled', 404),
|
||
('student_on_team_1_private_set_1', 'student_on_team_1_private_set_1', 403),
|
||
('student_on_team_2_private_set_1', 'student_on_team_1_private_set_1', 404),
|
||
('student_on_team_2_private_set_1', 'student_on_team_2_private_set_1', 404),
|
||
('staff', 'student_on_team_1_private_set_1', 204),
|
||
('staff', 'staff', 404),
|
||
)
|
||
def test_remove_user_from_private_teamset(self, user, user_to_remove, expected_status):
|
||
"""
|
||
As different users, attempt to remove themselves or student_on_team_1_private_set_1 from a
|
||
private_managed team.
|
||
(only student_on_team_1_private_set_1 is actually on this team)
|
||
Only staff should be able to remove, and all users other than student_on_team_1_private_set_1
|
||
should not be able to tell that the team exists in any way.
|
||
|
||
TODO: The only 403 that should remain is student_on_team_1_private_set_1. The other users should not be
|
||
able to tell that the team exists.
|
||
"""
|
||
self.delete_membership(
|
||
self.team_1_in_private_teamset_1.team_id,
|
||
self.users[user_to_remove].username,
|
||
expected_status,
|
||
user=user
|
||
)
|
||
|
||
|
||
class TestElasticSearchErrors(TeamAPITestCase):
|
||
"""Test that the Team API is robust to Elasticsearch connection errors."""
|
||
|
||
ES_ERROR = ConnectionError('N/A', 'connection error', {})
|
||
|
||
@patch.object(SearchEngine, 'get_search_engine', side_effect=ES_ERROR)
|
||
def test_list_teams(self, __):
|
||
"""Test that text searches return a 503 when Elasticsearch is down.
|
||
|
||
The endpoint should still return 200 when a search is not supplied."""
|
||
self.get_teams_list(
|
||
expected_status=503,
|
||
data={'course_id': str(self.test_course_1.id), 'text_search': 'zoinks'},
|
||
user='staff'
|
||
)
|
||
self.get_teams_list(
|
||
expected_status=200,
|
||
data={'course_id': str(self.test_course_1.id)},
|
||
user='staff'
|
||
)
|
||
|
||
@patch.object(SearchEngine, 'get_search_engine', side_effect=ES_ERROR)
|
||
def test_create_team(self, __):
|
||
"""Test that team creation is robust to Elasticsearch errors."""
|
||
self.post_create_team(
|
||
expected_status=200,
|
||
data=self.build_team_data(name='zoinks'),
|
||
user='staff'
|
||
)
|
||
|
||
@patch.object(SearchEngine, 'get_search_engine', side_effect=ES_ERROR)
|
||
def test_delete_team(self, __):
|
||
"""Test that team deletion is robust to Elasticsearch errors."""
|
||
self.delete_team(self.wind_team.team_id, 204, user='staff')
|
||
|
||
@patch.object(SearchEngine, 'get_search_engine', side_effect=ES_ERROR)
|
||
def test_patch_team(self, __):
|
||
"""Test that team updates are robust to Elasticsearch errors."""
|
||
self.patch_team_detail(
|
||
self.wind_team.team_id,
|
||
200,
|
||
data={'description': 'new description'},
|
||
user='staff'
|
||
)
|
||
|
||
|
||
@ddt.ddt
|
||
class TestBulkMembershipManagement(TeamAPITestCase):
|
||
"""
|
||
Test that CSVs can be uploaded and downloaded to manage course membership.
|
||
|
||
This test case will be expanded when the view is fully
|
||
implemented (TODO MST-31).
|
||
"""
|
||
good_course_id = 'TestX/TS101/Test_Course'
|
||
fake_course_id = 'TestX/TS101/Non_Existent_Course'
|
||
|
||
allow_username = 'course_staff'
|
||
deny_username = 'student_enrolled'
|
||
|
||
@ddt.data(
|
||
('GET', good_course_id, deny_username, 403),
|
||
('GET', fake_course_id, allow_username, 404),
|
||
('GET', fake_course_id, deny_username, 404),
|
||
('POST', good_course_id, deny_username, 403),
|
||
)
|
||
@ddt.unpack
|
||
def test_error_statuses(self, method, course_id, username, expected_status):
|
||
url = self.get_url(course_id)
|
||
self.login(username)
|
||
response = self.client.generic(method, url)
|
||
assert response.status_code == expected_status
|
||
|
||
def test_download_csv(self):
|
||
url = self.get_url(self.good_course_id)
|
||
self.login(self.allow_username)
|
||
response = self.client.get(url)
|
||
assert response.status_code == 200
|
||
assert response['Content-Type'] == 'text/csv'
|
||
assert response['Content-Disposition'] == (
|
||
'attachment; filename="team-membership_TestX_TS101_Test_Course.csv"'
|
||
)
|
||
# For now, just assert that the file is non-empty.
|
||
# Eventually, we will test contents (TODO MST-31).
|
||
assert response.content
|
||
|
||
@staticmethod
|
||
def get_url(course_id):
|
||
# This strategy allows us to test with invalid course IDs
|
||
return reverse('team_membership_bulk_management', args=[course_id])
|
||
|
||
def test_create_membership_via_upload(self):
|
||
self.create_and_enroll_student(username='a_user')
|
||
csv_content = 'user,mode,topic_0' + '\n'
|
||
csv_content += 'a_user,audit,team wind power'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
response = self.make_call(
|
||
reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
201,
|
||
method='post',
|
||
data={'csv': csv_file},
|
||
user='staff'
|
||
)
|
||
response_text = json.loads(response.content.decode('utf-8'))
|
||
assert response_text['message'] == '1 learners were affected.'
|
||
|
||
def test_upload_invalid_teamset(self):
|
||
self.create_and_enroll_student(username='a_user')
|
||
csv_content = 'user,mode,topic_0_bad' + '\n'
|
||
csv_content += 'a_user,audit,team wind power'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
self.make_call(
|
||
reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
400,
|
||
method='post',
|
||
data={'csv': csv_file},
|
||
user='staff'
|
||
)
|
||
|
||
def test_upload_assign_user_twice_to_same_teamset(self):
|
||
csv_content = 'user,mode,topic_0' + '\n'
|
||
csv_content += 'student_enrolled, masters, team wind power'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
self.make_call(
|
||
reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
400, method='post',
|
||
data={'csv': csv_file},
|
||
user='staff'
|
||
)
|
||
|
||
def test_upload_assign_one_user_to_different_teamsets(self):
|
||
self.create_and_enroll_student(username='a_user')
|
||
self.create_and_enroll_student(username='b_user')
|
||
self.create_and_enroll_student(username='c_user')
|
||
csv_content = 'user,mode,topic_0,topic_1,topic_2' + '\n'
|
||
csv_content += 'a_user,audit,team wind power,team 2' + '\n'
|
||
csv_content += 'b_user,audit,,team 2' + '\n'
|
||
csv_content += 'c_user,audit,,,team 3'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
response = self.make_call(reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
201, method='post', data={'csv': csv_file}, user='staff')
|
||
assert CourseTeam.objects.filter(name='team 2', course_id=self.test_course_1.id).count() == 1
|
||
response_text = json.loads(response.content.decode('utf-8'))
|
||
assert response_text['message'] == '3 learners were affected.'
|
||
|
||
def test_upload_non_existing_user(self):
|
||
csv_content = 'user,mode,topic_0' + '\n'
|
||
csv_content += 'missing_user, masters, team wind power'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
self.make_call(reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
400, method='post',
|
||
data={'csv': csv_file}, user='staff'
|
||
)
|
||
|
||
def test_upload_only_existing_courses(self):
|
||
self.create_and_enroll_student(username='a_user', mode=CourseMode.MASTERS)
|
||
self.create_and_enroll_student(username='b_user', mode=CourseMode.MASTERS)
|
||
existing_team_1 = CourseTeamFactory.create(
|
||
course_id=self.test_course_1.id,
|
||
topic_id='topic_1',
|
||
organization_protected=True
|
||
)
|
||
existing_team_2 = CourseTeamFactory.create(
|
||
course_id=self.test_course_1.id,
|
||
topic_id='topic_2',
|
||
organization_protected=True
|
||
)
|
||
|
||
csv_content = 'user,mode,topic_1,topic_2' + '\n'
|
||
csv_content += 'a_user,masters,{},{}'.format(
|
||
existing_team_1.name,
|
||
existing_team_2.name
|
||
) + '\n'
|
||
csv_content += 'b_user,masters,{},{}'.format(
|
||
existing_team_1.name,
|
||
existing_team_2.name
|
||
) + '\n'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
self.make_call(
|
||
reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
201,
|
||
method='post',
|
||
data={'csv': csv_file},
|
||
user='staff'
|
||
)
|
||
|
||
def test_upload_invalid_header(self):
|
||
self.create_and_enroll_student(username='a_user')
|
||
csv_content = 'mode,topic_1' + '\n'
|
||
csv_content += 'a_user,audit, team wind power'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
self.make_call(reverse(
|
||
'team_membership_bulk_management', args=[self.good_course_id]),
|
||
400, method='post',
|
||
data={'csv': csv_file}, user='staff'
|
||
)
|
||
|
||
def test_upload_invalid_more_teams_than_teamsets(self):
|
||
self.create_and_enroll_student(username='a_user')
|
||
csv_content = 'user,mode,topic_1' + '\n'
|
||
csv_content += 'a_user, masters, team wind power, extra1, extra2'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
self.make_call(reverse(
|
||
'team_membership_bulk_management',
|
||
args=[self.good_course_id]),
|
||
400, method='post',
|
||
data={'csv': csv_file}, user='staff'
|
||
)
|
||
|
||
def test_upload_invalid_student_enrollment_mismatch(self):
|
||
self.create_and_enroll_student(username='a_user', mode=CourseMode.AUDIT)
|
||
csv_content = 'user,mode,topic_1' + '\n'
|
||
csv_content += 'a_user,masters,team wind power'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
self.make_call(reverse(
|
||
'team_membership_bulk_management',
|
||
args=[self.good_course_id]),
|
||
400, method='post',
|
||
data={'csv': csv_file}, user='staff'
|
||
)
|
||
|
||
def test_upload_invalid_multiple_student_enrollment_mismatch(self):
|
||
audit_username = 'audit_user'
|
||
masters_username_a = 'masters_a'
|
||
masters_username_b = 'masters_b'
|
||
self.create_and_enroll_student(username=audit_username, mode=CourseMode.AUDIT)
|
||
self.create_and_enroll_student(username=masters_username_a, mode=CourseMode.MASTERS)
|
||
self.create_and_enroll_student(username=masters_username_b, mode=CourseMode.MASTERS)
|
||
|
||
csv_content = 'user,mode,topic_1' + '\n'
|
||
csv_content += f'{audit_username},audit,team wind power' + '\n'
|
||
csv_content += f'{masters_username_a},masters,team wind power' + '\n'
|
||
csv_content += f'{masters_username_b},masters,team wind power' + '\n'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
response = self.make_call(reverse(
|
||
'team_membership_bulk_management',
|
||
args=[self.good_course_id]),
|
||
400, method='post',
|
||
data={'csv': csv_file}, user='staff'
|
||
)
|
||
response_text = json.loads(response.content.decode('utf-8'))
|
||
expected_error = 'Team team wind power cannot have Master’s track users mixed with users in other tracks.'
|
||
assert response_text['errors'][0] == expected_error
|
||
|
||
def test_upload_learners_exceed_max_team_size(self):
|
||
csv_content = 'user,mode,topic_0,topic_1' + '\n'
|
||
team1 = 'team wind power'
|
||
team2 = 'team 2'
|
||
for name_enum in enumerate(['a', 'b', 'c', 'd', 'e', 'f', 'g']):
|
||
username = 'user_{}'.format(name_enum[1])
|
||
self.create_and_enroll_student(username=username, mode=CourseMode.MASTERS)
|
||
csv_content += f'{username},masters,{team1},{team2}' + '\n'
|
||
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
response = self.make_call(reverse(
|
||
'team_membership_bulk_management',
|
||
args=[self.good_course_id]),
|
||
400, method='post',
|
||
data={'csv': csv_file}, user='staff'
|
||
)
|
||
response_text = json.loads(response.content.decode('utf-8'))
|
||
assert response_text['errors'][0] == 'New membership for team {} would exceed max size of {}.'.format(team1, 3)
|
||
|
||
def test_deletion_via_upload_csv(self):
|
||
# create a team membership that will be used further down
|
||
self.test_create_membership_via_upload()
|
||
username = 'a_user'
|
||
topic_0_id = 'topic_0'
|
||
assert CourseTeamMembership.objects.filter(user_id=self.users[username].id, team__topic_id=topic_0_id).exists()
|
||
|
||
csv_content = f'user,mode,{topic_0_id},topic_1' + '\n'
|
||
csv_content += f'{username},audit'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
self.make_call(
|
||
reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
201,
|
||
method='post',
|
||
data={'csv': csv_file},
|
||
user='staff'
|
||
)
|
||
assert not CourseTeamMembership.objects\
|
||
.filter(user_id=self.users[username].id, team__topic_id=topic_0_id).exists()
|
||
|
||
def test_reassignment_via_upload_csv(self):
|
||
# create a team membership that will be used further down
|
||
self.test_create_membership_via_upload()
|
||
username = 'a_user'
|
||
topic_0_id = 'topic_0'
|
||
nuclear_team_name = 'team nuclear power'
|
||
windpower_team_name = 'team wind power'
|
||
assert CourseTeamMembership.objects\
|
||
.filter(user_id=self.users[username].id, team__topic_id=topic_0_id, team__name=windpower_team_name).exists()
|
||
csv_content = f'user,mode,{topic_0_id}' + '\n'
|
||
csv_content += f'{username},audit,{nuclear_team_name}'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
self.make_call(
|
||
reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
201,
|
||
method='post',
|
||
data={'csv': csv_file},
|
||
user='staff'
|
||
)
|
||
assert not CourseTeamMembership.objects.filter(user_id=self.users[username].id,
|
||
team__topic_id=topic_0_id,
|
||
team__name=windpower_team_name).exists()
|
||
|
||
assert CourseTeamMembership.objects.filter(user_id=self.users[username].id,
|
||
team__topic_id=topic_0_id,
|
||
team__name=nuclear_team_name).exists()
|
||
|
||
def test_upload_file_not_changed_csv(self):
|
||
# create a team membership that will be used further down
|
||
self.test_create_membership_via_upload()
|
||
username = 'a_user'
|
||
topic_0_id = 'topic_0'
|
||
nuclear_team_name = 'team wind power'
|
||
assert len(CourseTeamMembership.objects.filter(user_id=self.users[username].id, team__topic_id=topic_0_id)) == 1
|
||
csv_content = f'user,mode,{topic_0_id}' + '\n'
|
||
csv_content += f'{username},audit,{nuclear_team_name}'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username,
|
||
password=self.users['course_staff'].password)
|
||
self.make_call(
|
||
reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
201,
|
||
method='post',
|
||
data={'csv': csv_file},
|
||
user='staff'
|
||
)
|
||
assert len(CourseTeamMembership.objects.filter(user_id=self.users[username].id,
|
||
team__name=nuclear_team_name)) == 1
|
||
assert CourseTeamMembership.objects.filter(user_id=self.users[username].id,
|
||
team__name=nuclear_team_name).exists()
|
||
|
||
def test_create_membership_via_upload_using_external_key(self):
|
||
self.create_and_enroll_student(username='a_user', external_key='a_user_external_key')
|
||
csv_content = 'user,mode,topic_0' + '\n'
|
||
csv_content += 'a_user_external_key,audit,team wind power'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
response = self.make_call(
|
||
reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
201,
|
||
method='post',
|
||
data={'csv': csv_file},
|
||
user='staff'
|
||
)
|
||
response_text = json.loads(response.content.decode('utf-8'))
|
||
assert response_text['message'] == '1 learners were affected.'
|
||
|
||
def test_create_membership_via_upload_using_external_key_invalid(self):
|
||
self.create_and_enroll_student(username='a_user', external_key='a_user_external_key')
|
||
csv_content = 'user,mode,topic_0' + '\n'
|
||
csv_content += 'a_user_external_key_invalid,audit,team wind power'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
response = self.make_call(
|
||
reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
400,
|
||
method='post',
|
||
data={'csv': csv_file},
|
||
user='staff'
|
||
)
|
||
response_text = json.loads(response.content.decode('utf-8'))
|
||
assert response_text['errors'] == ['User name/email/external key: a_user_external_key_invalid does not exist.']
|
||
|
||
def test_upload_non_ascii(self):
|
||
csv_content = 'user,mode,topic_0' + '\n'
|
||
team_name = '著文企臺個'
|
||
user_name = '著著文企臺個文企臺個'
|
||
self.create_and_enroll_student(username=user_name)
|
||
csv_content += f'{user_name},audit,{team_name}'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
self.make_call(
|
||
reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
201, method='post',
|
||
data={'csv': csv_file},
|
||
user='staff'
|
||
)
|
||
team = self.users[user_name].teams.first()
|
||
assert team.name == team_name
|
||
assert [user.username for user in team.users.all()] == [user_name]
|
||
|
||
def test_upload_assign_masters_learner_to_non_protected_team(self):
|
||
"""
|
||
Scenario: Attempt to add a learner enrolled in masters track to an existing, non-org protected team.
|
||
Outcome: Must fail
|
||
"""
|
||
masters_a = 'masters_a'
|
||
team = self.wind_team
|
||
self.create_and_enroll_student(username=masters_a, mode=CourseMode.MASTERS)
|
||
csv_content = f'user,mode,{team.topic_id}' + '\n'
|
||
csv_content += f'masters_a, masters,{team.name}'
|
||
csv_file = SimpleUploadedFile('test_file.csv', csv_content.encode('utf8'), content_type='text/csv')
|
||
self.client.login(username=self.users['course_staff'].username, password=self.users['course_staff'].password)
|
||
|
||
response = self.make_call(
|
||
reverse('team_membership_bulk_management', args=[self.good_course_id]),
|
||
400, method='post',
|
||
data={'csv': csv_file},
|
||
user='staff'
|
||
)
|
||
response_text = json.loads(response.content.decode('utf-8'))
|
||
expected_message = 'Team {} cannot have Master’s track users mixed with users in other tracks.'.format(
|
||
team.name
|
||
)
|
||
assert response_text['errors'][0] == expected_message
|