def test_scoped_within_course(self):
"""Verify that team count is scoped within a course."""
duplicate_topic = self.course.teamsets[0].cleaned_data
second_course = CourseFactory.create(teams_configuration=TeamsConfig({
"max_team_size":
10,
"topics": [duplicate_topic]
}), )
CourseTeamFactory.create(course_id=self.course.id,
topic_id=duplicate_topic['id'])
CourseTeamFactory.create(course_id=second_course.id,
topic_id=duplicate_topic['id'])
with self.assertNumQueries(
3): # 2 split modulestore MySQL queries, 1 for Teams
serializer = TopicSerializer(
self.course.teamsets[0].cleaned_data,
context={'course_id': self.course.id},
)
assert serializer.data == {
'name': 'Tøpic',
'description': 'The bést topic!',
'id': '0',
'team_count': 1,
'type': 'open',
'max_team_size': None
}
def test_team_discussion_id_not_cohorted(self, mock_request):
team = CourseTeamFactory(course_id=self.course.id)
team.add_user(self.student)
self.call_view(mock_request, team.discussion_topic_id, self.student, None)
self._assert_comments_service_called_without_group_id(mock_request)
def setUp(self):
"""
Set up tests.
"""
super().setUp()
self.user1 = UserFactory.create(username='******')
self.user2 = UserFactory.create(username='******')
self.user3 = UserFactory.create(username='******')
for user in (self.user1, self.user2, self.user3):
CourseEnrollmentFactory.create(user=user, course_id=COURSE_KEY1)
CourseEnrollmentFactory.create(user=self.user1, course_id=COURSE_KEY2)
self.team1 = CourseTeamFactory(
course_id=COURSE_KEY1,
team_id='team1',
topic_id=TEAMSET_1_ID,
)
self.team2 = CourseTeamFactory(
course_id=COURSE_KEY2,
team_id='team2',
topic_id=TEAMSET_2_ID,
)
self.team_membership11 = self.team1.add_user(self.user1)
self.team_membership12 = self.team1.add_user(self.user2)
self.team_membership21 = self.team2.add_user(self.user1)
def test_add_incompatible_mode_to_existing_protected_team_fails(self):
# Given an existing protected team
protected_team = CourseTeamFactory(
course_id=self.course.id,
name='protected_team',
topic_id='teamset_1',
organization_protected=True,
)
masters_learner = self._create_and_enroll_test_user('masters_learner',
mode='masters')
protected_team.add_user(masters_learner)
# When I attempt to add a student of an incompatible enrollment mode
verified_learner = self._create_and_enroll_test_user(
'verified_learner', mode='verified')
csv_data = self._csv_reader_from_array(
[['username', 'mode', 'teamset_1'],
[verified_learner.username, 'verified', 'protected_team']])
result = self.import_manager.set_team_memberships(csv_data)
# The import fails with "mixed users" error and learner not added to team
assert not result
self.assert_no_events_were_emitted()
assert self.import_manager.validation_errors[0] ==\
'Team protected_team cannot have Master’s track users mixed with users in other tracks.'
assert not CourseTeamMembership.is_user_on_team(
verified_learner, protected_team)
def test_scoped_within_course(self):
"""Verify that team count is scoped within a course."""
duplicate_topic = self.course.teamsets[0].cleaned_data
second_course = CourseFactory.create(teams_configuration=TeamsConfig({
"max_team_size":
10,
"topics": [duplicate_topic]
}), )
CourseTeamFactory.create(course_id=self.course.id,
topic_id=duplicate_topic[u'id'])
CourseTeamFactory.create(course_id=second_course.id,
topic_id=duplicate_topic[u'id'])
with self.assertNumQueries(1):
serializer = TopicSerializer(
self.course.teamsets[0].cleaned_data,
context={'course_id': self.course.id},
)
self.assertEqual(
serializer.data, {
u'name': u'Tøpic',
u'description': u'The bést topic!',
u'id': u'0',
u'team_count': 1,
u'type': u'open'
})
def test_team_discussion_id_not_cohorted(self, mock_request):
team = CourseTeamFactory(course_id=self.course.id)
team.add_user(self.student) # pylint: disable=no-member
self.call_view(mock_request, team.discussion_topic_id, self.student, None)
self._assert_comments_service_called_without_group_id(mock_request)
def test_user_moved_to_another_team(self):
""" We should be able to move a user from one team to another """
# Create a learner, enroll in course
audit_learner = UserFactory.create(username='******')
CourseEnrollmentFactory.create(user=audit_learner,
course_id=self.course.id,
mode='audit')
# Make two teams in the same teamset, enroll the user in one
team_1 = CourseTeamFactory(course_id=self.course.id,
name='test_team_1',
topic_id='teamset_1')
team_2 = CourseTeamFactory(course_id=self.course.id,
name='test_team_2',
topic_id='teamset_1')
team_1.add_user(audit_learner)
csv_row = _csv_dict_row(audit_learner,
'',
'audit',
teamset_1=team_2.name)
csv_import(self.course, [csv_row])
assert not CourseTeamMembership.is_user_on_team(audit_learner, team_1)
assert CourseTeamMembership.is_user_on_team(audit_learner, team_2)
self.assert_learner_removed_emitted(team_1.team_id, audit_learner.id)
self.assert_learner_added_emitted(team_2.team_id, audit_learner.id)
def setUpClass(cls):
super().setUpClass()
cls.user_audit = UserFactory.create(username='******')
cls.user_staff = UserFactory.create(username='******')
cls.user_masters = UserFactory.create(username='******')
cls.user_unenrolled = UserFactory.create(username='******')
cls.users = {
'user_audit': cls.user_audit,
'user_staff': cls.user_staff,
'user_masters': cls.user_masters,
'user_unenrolled': cls.user_unenrolled,
}
cls.topic_id = 'RANDOM TOPIC'
cls.course_1 = CourseFactory.create(
teams_configuration=TeamsConfig({
'team_sets': [{'id': cls.topic_id, 'name': cls.topic_id, 'description': cls.topic_id}]
}),
org=COURSE_KEY1.org,
course=COURSE_KEY1.course,
run=COURSE_KEY1.run
)
for user in (cls.user_audit, cls.user_staff):
CourseEnrollmentFactory.create(user=user, course_id=COURSE_KEY1)
CourseEnrollmentFactory.create(user=cls.user_masters, course_id=COURSE_KEY1, mode=CourseMode.MASTERS)
CourseStaffRole(COURSE_KEY1).add_users(cls.user_staff)
cls.team_unprotected_1 = CourseTeamFactory(
course_id=COURSE_KEY1,
topic_id=cls.topic_id,
team_id='team_unprotected_1'
)
cls.team_unprotected_2 = CourseTeamFactory(
course_id=COURSE_KEY1,
topic_id=cls.topic_id,
team_id='team_unprotected_2'
)
cls.team_unprotected_3 = CourseTeamFactory(
course_id=COURSE_KEY1,
topic_id=cls.topic_id,
team_id='team_unprotected_3'
)
cls.team_protected_1 = CourseTeamFactory(
course_id=COURSE_KEY1,
team_id='team_protected_1',
topic_id=cls.topic_id,
organization_protected=True
)
cls.team_protected_2 = CourseTeamFactory(
course_id=COURSE_KEY1,
team_id='team_protected_2',
topic_id=cls.topic_id,
organization_protected=True
)
def test_load_course_teams(self):
"""
Loading course teams should get the users by team with only 2 queries
1 for teams, 1 for user count
"""
for _ in range(4):
CourseTeamFactory.create(course_id=self.course.id)
with self.assertNumQueries(2):
self.import_manager.load_course_teams()
def test_load_course_teams(self):
"""
Lodaing course teams shold get the users by team with only 2 queries
1 for teams, 1 for user count
"""
team1 = CourseTeamFactory.create(course_id=self.course.id)
team2 = CourseTeamFactory.create(course_id=self.course.id)
team3 = CourseTeamFactory.create(course_id=self.course.id)
team4 = CourseTeamFactory.create(course_id=self.course.id)
with self.assertNumQueries(2):
self.import_manager.load_course_teams()
def test_topic_with_team_count(self):
"""
Verifies that the `TopicSerializer` correctly displays a topic with a
positive team count, and that it only takes one SQL query.
"""
CourseTeamFactory.create(course_id=self.course.id, topic_id=self.course.teams_topics[0]['id'])
with self.assertNumQueries(1):
serializer = TopicSerializer(self.course.teams_topics[0], context={'course_id': self.course.id})
self.assertEqual(
serializer.data,
{u'name': u'Tøpic', u'description': u'The bést topic!', u'id': u'0', u'team_count': 1}
)
def test_scoped_within_course(self):
"""Verify that team counts are scoped within a course."""
teams_per_topic = 10
first_course_topics = self.setup_topics(num_topics=self.NUM_TOPICS, teams_per_topic=teams_per_topic)
duplicate_topic = first_course_topics[0]
second_course = CourseFactory.create(
teams_configuration={
"max_team_size": 10,
"topics": [duplicate_topic]
}
)
CourseTeamFactory.create(course_id=second_course.id, topic_id=duplicate_topic[u'id'])
self.assert_serializer_output(first_course_topics, num_teams_per_topic=teams_per_topic, num_queries=1)
def test_scoped_within_course(self):
"""Verify that team counts are scoped within a course."""
teams_per_topic = 10
first_course_topics = self.setup_topics(num_topics=self.NUM_TOPICS, teams_per_topic=teams_per_topic)
duplicate_topic = first_course_topics[0]
second_course = CourseFactory.create(
teams_configuration=TeamsConfig({
"max_team_size": 10,
"topics": [duplicate_topic]
}),
)
CourseTeamFactory.create(course_id=second_course.id, topic_id=duplicate_topic[u'id'])
self.assert_serializer_output(first_course_topics, num_teams_per_topic=teams_per_topic, num_queries=1)
def test_team_removals_are_scoped_correctly(self):
""" Team memberships should not search across topics in different courses """
# Given a learner enrolled in similarly named teamsets across 2 courses
audit_learner = UserFactory.create(username='******')
CourseEnrollmentFactory.create(user=audit_learner, course_id=self.course.id, mode='audit')
course_1_team = CourseTeamFactory(course_id=self.course.id, name='cross_course_test', topic_id='teamset_1')
course_1_team.add_user(audit_learner)
CourseEnrollmentFactory.create(user=audit_learner, course_id=self.second_course.id, mode='audit')
course_2_team = CourseTeamFactory(
course_id=self.second_course.id,
name='cross_course_test',
topic_id='teamset_1'
)
course_2_team.add_user(audit_learner)
self.assertTrue(CourseTeamMembership.is_user_on_team(audit_learner, course_1_team))
# When I try to remove them from the team
row = {
'mode': 'audit',
'teamset_1': None,
'user': audit_learner
}
self.import_manager.remove_user_from_team_for_reassignment(row)
# They are successfully removed from the team
self.assertFalse(CourseTeamMembership.is_user_on_team(audit_learner, course_1_team))
self.assert_learner_removed_emitted(course_1_team.team_id, audit_learner.id)
def setUp(self): # pylint: disable=arguments-differ
"""Create a user with a team to test signals."""
super(TeamSignalsTest, self).setUp('lms.djangoapps.teams.utils.tracker') # lint-amnesty, pylint: disable=super-with-arguments
self.user = UserFactory.create(username="******")
self.moderator = UserFactory.create(username="******")
self.team = CourseTeamFactory(discussion_topic_id=self.DISCUSSION_TOPIC_ID)
self.team_membership = CourseTeamMembershipFactory(user=self.user, team=self.team)
def setUp(self):
"""Create a user with a team to test signals."""
super(TeamSignalsTest, self).setUp('lms.djangoapps.teams.utils.tracker')
self.user = UserFactory.create(username="******")
self.moderator = UserFactory.create(username="******")
self.team = CourseTeamFactory(discussion_topic_id=self.DISCUSSION_TOPIC_ID)
self.team_membership = CourseTeamMembershipFactory(user=self.user, team=self.team)
def setup_topics(self, num_topics=5, teams_per_topic=0):
"""
Helper method to set up topics on the course. Returns a list of
created topics.
"""
self.course.teams_configuration['topics'] = []
topics = [
{u'name': u'Tøpic {}'.format(i), u'description': u'The bést topic! {}'.format(i), u'id': unicode(i)}
for i in xrange(num_topics)
]
for i in xrange(num_topics):
topic_id = unicode(i)
self.course.teams_configuration['topics'].append(topics[i])
for _ in xrange(teams_per_topic):
CourseTeamFactory.create(course_id=self.course.id, topic_id=topic_id)
return topics
def setUpClass(cls):
super(TeamAccessTests, cls).setUpClass()
cls.user_audit = UserFactory.create(username='******')
cls.user_staff = UserFactory.create(username='******')
cls.user_masters = UserFactory.create(username='******')
cls.user_unenrolled = UserFactory.create(username='******')
cls.users = {
'user_audit': cls.user_audit,
'user_staff': cls.user_staff,
'user_masters': cls.user_masters,
'user_unenrolled': cls.user_unenrolled,
}
for user in (cls.user_audit, cls.user_staff):
CourseEnrollmentFactory.create(user=user, course_id=COURSE_KEY1)
CourseEnrollmentFactory.create(user=cls.user_masters, course_id=COURSE_KEY1, mode=CourseMode.MASTERS)
CourseStaffRole(COURSE_KEY1).add_users(cls.user_staff)
cls.topic_id = 'RANDOM TOPIC'
cls.team_unprotected_1 = CourseTeamFactory(
course_id=COURSE_KEY1,
topic_id=cls.topic_id,
team_id='team_unprotected_1'
)
cls.team_unprotected_2 = CourseTeamFactory(
course_id=COURSE_KEY1,
topic_id=cls.topic_id,
team_id='team_unprotected_2'
)
cls.team_unprotected_3 = CourseTeamFactory(
course_id=COURSE_KEY1,
topic_id=cls.topic_id,
team_id='team_unprotected_3'
)
cls.team_protected_1 = CourseTeamFactory(
course_id=COURSE_KEY1,
team_id='team_protected_1',
topic_id=cls.topic_id,
organization_protected=True
)
cls.team_protected_2 = CourseTeamFactory(
course_id=COURSE_KEY1,
team_id='team_protected_2',
topic_id=cls.topic_id,
organization_protected=True
)
def test_topic_with_team_count(self):
"""
Verifies that the `TopicSerializer` correctly displays a topic with a
positive team count, and that it only takes one SQL query.
"""
CourseTeamFactory.create(course_id=self.course.id,
topic_id=self.course.teams_topics[0]['id'])
with self.assertNumQueries(1):
serializer = TopicSerializer(self.course.teams_topics[0],
context={'course_id': self.course.id})
self.assertEqual(
serializer.data, {
u'name': u'Tøpic',
u'description': u'The bést topic!',
u'id': u'0',
u'team_count': 1
})
def test_scoped_within_course(self):
"""Verify that team count is scoped within a course."""
duplicate_topic = self.course.teams_topics[0]
second_course = CourseFactory.create(
teams_configuration={
"max_team_size": 10,
"topics": [duplicate_topic]
}
)
CourseTeamFactory.create(course_id=self.course.id, topic_id=duplicate_topic[u'id'])
CourseTeamFactory.create(course_id=second_course.id, topic_id=duplicate_topic[u'id'])
with self.assertNumQueries(1):
serializer = TopicSerializer(self.course.teams_topics[0], context={'course_id': self.course.id})
self.assertEqual(
serializer.data,
{u'name': u'Tøpic', u'description': u'The bést topic!', u'id': u'0', u'team_count': 1}
)
def setUp(self):
super(MembershipSerializerTestCase, self).setUp()
self.team = CourseTeamFactory.create(
course_id=self.course.id,
topic_id=self.course.teamsets[0].teamset_id,
)
self.user = UserFactory.create()
CourseEnrollmentFactory.create(user=self.user, course_id=self.course.id)
self.team_membership = CourseTeamMembershipFactory.create(team=self.team, user=self.user)
def setup_topics(self, num_topics=5, teams_per_topic=0):
"""
Helper method to set up topics on the course. Returns a list of
created topics.
"""
self.course.teams_configuration['topics'] = []
topics = [{
u'name': u'Tøpic {}'.format(i),
u'description': u'The bést topic! {}'.format(i),
u'id': unicode(i)
} for i in xrange(num_topics)]
for i in xrange(num_topics):
topic_id = unicode(i)
self.course.teams_configuration['topics'].append(topics[i])
for _ in xrange(teams_per_topic):
CourseTeamFactory.create(course_id=self.course.id,
topic_id=topic_id)
return topics
def setUp(self):
super(MembershipSerializerTestCase, self).setUp()
self.team = CourseTeamFactory.create(
course_id=self.course.id,
topic_id=self.course.teams_topics[0]['id']
)
self.user = UserFactory.create()
CourseEnrollmentFactory.create(user=self.user, course_id=self.course.id)
self.team_membership = CourseTeamMembershipFactory.create(team=self.team, user=self.user)
def setUp(self):
super(TeamsServiceTests, self).setUp()
self.course_run = CourseRunFactory.create()
self.course_key = self.course_run['key']
self.team = CourseTeamFactory.create(course_id=self.course_key)
self.service = TeamsService()
self.user = UserFactory.create()
CourseEnrollmentFactory.create(user=self.user, course_id=self.course_key)
self.team.add_user(self.user)
def setUp(self):
super(TeamsServiceTests, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
self.course_run = CourseRunFactory.create()
self.course_key = self.course_run['key']
self.team = CourseTeamFactory.create(course_id=self.course_key)
self.service = TeamsService()
self.user = UserFactory.create()
CourseEnrollmentFactory.create(user=self.user,
course_id=self.course_key)
self.team.add_user(self.user)
def test_remove_from_team(self):
# Given a user already in a course and on a team
user = UserFactory.create(username='******')
mode = 'audit'
CourseEnrollmentFactory.create(user=user, course_id=self.course.id, mode=mode)
team = CourseTeamFactory(course_id=self.course.id, name='team_1', topic_id='teamset_1')
team.add_user(user)
self.assertTrue(CourseTeamMembership.is_user_on_team(user, team))
# When I try to remove them from the team
csv_data = self._csv_reader_from_array([
['user', 'mode', 'teamset_1'],
[user.username, mode, ''],
])
result = self.import_manager.set_team_memberships(csv_data)
# Then they are removed from the team and the correct events are issued
self.assertFalse(CourseTeamMembership.is_user_on_team(user, team))
self.assert_learner_removed_emitted(team.team_id, user.id)
def setUpClass(cls):
super(PythonAPITests, cls).setUpClass()
cls.user1 = UserFactory.create(username='******')
cls.user2 = UserFactory.create(username='******')
cls.user3 = UserFactory.create(username='******')
for user in (cls.user1, cls.user2, cls.user3):
CourseEnrollmentFactory.create(user=user, course_id=COURSE_KEY1)
CourseEnrollmentFactory.create(user=cls.user3, course_id=COURSE_KEY2)
cls.team1 = CourseTeamFactory(course_id=COURSE_KEY1,
discussion_topic_id=DISCUSSION_TOPIC_ID,
team_id='team1')
cls.team2 = CourseTeamFactory(course_id=COURSE_KEY2, team_id='team2')
cls.team1.add_user(cls.user1)
cls.team1.add_user(cls.user2)
cls.team2.add_user(cls.user3)
def setUpClass(cls):
super(TestModelStrings, cls).setUpClass()
cls.user = UserFactory.create(username="******")
CourseEnrollmentFactory.create(user=cls.user,
course_id="edx/the-course/1")
cls.team = CourseTeamFactory(course_id="edx/the-course/1",
team_id="the-team",
topic_id=TEAMSET_1_ID,
name="The Team")
cls.team_membership = cls.team.add_user(cls.user)
def setUp(self):
"""
Set up tests.
"""
super(TeamMembershipTest, self).setUp()
self.user1 = UserFactory.create(username='******')
self.user2 = UserFactory.create(username='******')
self.user3 = UserFactory.create(username='******')
for user in (self.user1, self.user2, self.user3):
CourseEnrollmentFactory.create(user=user, course_id=COURSE_KEY1)
CourseEnrollmentFactory.create(user=self.user1, course_id=COURSE_KEY2)
self.team1 = CourseTeamFactory(course_id=COURSE_KEY1, team_id='team1')
self.team2 = CourseTeamFactory(course_id=COURSE_KEY2, team_id='team2')
self.team_membership11 = self.team1.add_user(self.user1)
self.team_membership12 = self.team1.add_user(self.user2)
self.team_membership21 = self.team2.add_user(self.user1)
def setUp(self):
super(MembershipSerializerTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
self.team = CourseTeamFactory.create(
course_id=self.course.id,
topic_id=self.course.teamsets[0].teamset_id,
)
self.user = UserFactory.create()
CourseEnrollmentFactory.create(user=self.user,
course_id=self.course.id)
self.team_membership = CourseTeamMembershipFactory.create(
team=self.team, user=self.user)
def test_topic_with_team_count(self):
"""
Verifies that the `TopicSerializer` correctly displays a topic with a
positive team count, and that it takes a known number of SQL queries.
"""
CourseTeamFactory.create(course_id=self.course.id,
topic_id=self.course.teamsets[0].teamset_id)
with self.assertNumQueries(2):
serializer = TopicSerializer(
self.course.teamsets[0].cleaned_data,
context={'course_id': self.course.id},
)
assert serializer.data == {
'name': 'Tøpic',
'description': 'The bést topic!',
'id': '0',
'team_count': 1,
'type': 'open',
'max_team_size': None
}
def setup_topics(self, num_topics=5, teams_per_topic=0):
"""
Helper method to set up topics on the course. Returns a list of
created topics.
"""
topics = [{
u'name': u'Tøpic {}'.format(i),
u'description': u'The bést topic! {}'.format(i),
u'id': six.text_type(i)
} for i in six.moves.range(num_topics)]
for topic in topics:
for _ in six.moves.range(teams_per_topic):
CourseTeamFactory.create(course_id=self.course.id,
topic_id=topic['id'])
self.course.teams_configuration = TeamsConfig({
'max_team_size':
self.course.teams_configuration.default_max_team_size,
'topics':
topics,
})
return topics
def setUpClass(cls):
super(CourseTeamTest, cls).setUpClass()
cls.audit_learner = UserFactory.create(username="******")
CourseEnrollmentFactory.create(user=cls.audit_learner,
course_id="edx/the-course/1",
mode=CourseMode.AUDIT)
cls.audit_team = CourseTeamFactory(course_id="edx/the-course/1",
team_id="audit-team",
topic_id=TEAMSET_1_ID,
name="The Team")
cls.masters_learner = UserFactory.create(username="******")
CourseEnrollmentFactory.create(user=cls.masters_learner,
course_id="edx/the-course/1",
mode=CourseMode.MASTERS)
cls.masters_team = CourseTeamFactory(course_id="edx/the-course/1",
team_id="masters-team",
topic_id=TEAMSET_1_ID,
name="The Team",
organization_protected=True)
def setup_team(self):
""" Set up a team with teammates and StudentModules """
# Make users
self.teammate_a = UserFactory()
self.teammate_b = UserFactory()
# This teammate has never opened the assignment so they don't have a state
self.lazy_teammate = UserFactory()
# Enroll users in course, so we can add them to the team with add_user
CourseEnrollment.enroll(self.user, self.course_key)
CourseEnrollment.enroll(self.teammate_a, self.course_key)
CourseEnrollment.enroll(self.teammate_b, self.course_key)
CourseEnrollment.enroll(self.lazy_teammate, self.course_key)
# Make team
self.team = CourseTeamFactory.create(
course_id=self.course_key,
topic_id=self.team_enabled_ora.selected_teamset_id)
# Add users to team
self.team.add_user(self.user)
self.team.add_user(self.teammate_a)
self.team.add_user(self.teammate_b)
self.team.add_user(self.lazy_teammate)
# Create student modules for everyone but lazy_student
self.team_state_dict = {
'attempts':
1,
'saved_files_descriptions': ['summary', 'proposal', 'diagrams'],
'saved_files_sizes': [1364677, 958418],
'saved_files_names':
['case_study_abstract.txt', 'design_prop.pdf', 'diagram1.png']
}
team_state = json.dumps(self.team_state_dict)
StudentModule.objects.create(
student=self.user,
course_id=self.course_key,
module_state_key=self.team_enabled_ora.location,
state=team_state,
)
StudentModule.objects.create(
student=self.teammate_a,
course_id=self.course_key,
module_state_key=self.team_enabled_ora.location,
state=team_state,
)
StudentModule.objects.create(
student=self.teammate_b,
course_id=self.course_key,
module_state_key=self.team_enabled_ora.location,
state=team_state,
)
def setUpClass(cls):
super().setUpClass()
cls.course_id = "edx/the-course/1"
cls.course1 = create_course(CourseKey.from_string(cls.course_id),
TEAMS_CONFIG_1)
cls.user = UserFactory.create(username="******")
CourseEnrollmentFactory.create(user=cls.user, course_id=cls.course_id)
cls.team = CourseTeamFactory(course_id=cls.course_id,
team_id="the-team",
topic_id=TEAMSET_1_ID,
name="The Team")
cls.team_membership = cls.team.add_user(cls.user)
def setUpClass(cls):
super().setUpClass()
cls.teamset_id = 'teamset_id'
teams_config = TeamsConfig({
'team_sets': [{
'id': cls.teamset_id,
'name': 'teamset_name',
'description': 'teamset_desc',
}]
})
cls.course = CourseFactory(teams_configuration=teams_config)
# pylint: disable=protected-access
cls.header_fields = csv._get_team_membership_csv_headers(cls.course)
cls.team = CourseTeamFactory(course_id=cls.course.id,
name='team_name',
topic_id=cls.teamset_id)
cls.user_no_program = UserFactory.create()
cls.user_in_program = UserFactory.create()
cls.user_in_program_no_external_id = UserFactory.create()
cls.user_in_program_not_enrolled_through_program = UserFactory.create()
# user_no_program is only enrolled in the course
cls.add_user_to_course_program_team(cls.user_no_program,
enroll_in_program=False)
# user_in_program is enrolled in the course and the program, with an external_id
cls.external_user_key = 'externalProgramUserId-123'
cls.add_user_to_course_program_team(
cls.user_in_program, external_user_key=cls.external_user_key)
# user_in_program is enrolled in the course and the program, with no external_id
cls.add_user_to_course_program_team(cls.user_in_program_no_external_id)
# user_in_program_not_enrolled_through_program is enrolled in a program and the course, but they not connected
cls.add_user_to_course_program_team(
cls.user_in_program_not_enrolled_through_program,
connect_enrollments=False)
# initialize import manager
cls.import_manager = csv.TeamMembershipImportManager(cls.course)
cls.import_manager.teamset_ids = {
ts.teamset_id
for ts in cls.course.teamsets
}
def test_get_team_names(self):
"""
get_team_names will return a dict mapping the team id to the team name for all teams in the given teamset
"""
additional_teams = [
CourseTeamFactory.create(course_id=self.course_key,
topic_id=self.team.topic_id)
for _ in range(3)
]
result = self.service.get_team_names(self.course_key,
self.team.topic_id)
assert result == {
self.team.team_id: self.team.name,
additional_teams[0].team_id: additional_teams[0].name,
additional_teams[1].team_id: additional_teams[1].name,
additional_teams[2].team_id: additional_teams[2].name,
}
class TeamMembershipTest(SharedModuleStoreTestCase):
"""Tests for the TeamMembership model."""
shard = 4
def setUp(self):
"""
Set up tests.
"""
super(TeamMembershipTest, self).setUp()
self.user1 = UserFactory.create(username='******')
self.user2 = UserFactory.create(username='******')
self.user3 = UserFactory.create(username='******')
for user in (self.user1, self.user2, self.user3):
CourseEnrollmentFactory.create(user=user, course_id=COURSE_KEY1)
CourseEnrollmentFactory.create(user=self.user1, course_id=COURSE_KEY2)
self.team1 = CourseTeamFactory(course_id=COURSE_KEY1, team_id='team1')
self.team2 = CourseTeamFactory(course_id=COURSE_KEY2, team_id='team2')
self.team_membership11 = self.team1.add_user(self.user1)
self.team_membership12 = self.team1.add_user(self.user2)
self.team_membership21 = self.team2.add_user(self.user1)
def test_membership_last_activity_set(self):
current_last_activity = self.team_membership11.last_activity_at
# Assert that the first save in the setUp sets a value.
self.assertIsNotNone(current_last_activity)
self.team_membership11.save()
# Verify that we only change the last activity_at when it doesn't
# already exist.
self.assertEqual(self.team_membership11.last_activity_at, current_last_activity)
def test_team_size_delete_membership(self):
"""Test that the team size field is correctly updated when deleting a
team membership.
"""
self.assertEqual(self.team1.team_size, 2)
self.team_membership11.delete()
team = CourseTeam.objects.get(id=self.team1.id)
self.assertEqual(team.team_size, 1)
def test_team_size_create_membership(self):
"""Test that the team size field is correctly updated when creating a
team membership.
"""
self.assertEqual(self.team1.team_size, 2)
self.team1.add_user(self.user3)
team = CourseTeam.objects.get(id=self.team1.id)
self.assertEqual(team.team_size, 3)
@ddt.data(
(None, None, None, 3),
('user1', None, None, 2),
('user1', [COURSE_KEY1], None, 1),
('user1', None, 'team1', 1),
('user2', None, None, 1),
)
@ddt.unpack
def test_get_memberships(self, username, course_ids, team_id, expected_count):
self.assertEqual(
CourseTeamMembership.get_memberships(username=username, course_ids=course_ids, team_id=team_id).count(),
expected_count
)
@ddt.data(
('user1', COURSE_KEY1, True),
('user2', COURSE_KEY1, True),
('user2', COURSE_KEY2, False),
)
@ddt.unpack
def test_user_in_team_for_course(self, username, course_id, expected_value):
user = getattr(self, username)
self.assertEqual(
CourseTeamMembership.user_in_team_for_course(user, course_id),
expected_value
)
