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 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_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 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_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 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)
class TeamMembershipTest(SharedModuleStoreTestCase):
"""Tests for the TeamMembership model."""
@classmethod
def setUpClass(cls):
super().setUpClass()
create_course(COURSE_KEY1, TEAMS_CONFIG_1)
create_course(COURSE_KEY2, TEAMS_CONFIG_2)
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_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_ids,
expected_count):
self.assertEqual(
CourseTeamMembership.get_memberships(username=username,
course_ids=course_ids,
team_ids=team_ids).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)
@ddt.data(
('user1', COURSE_KEY1, TEAMSET_1_ID, True),
('user1', COURSE_KEY1, TEAMSET_2_ID, False),
('user2', COURSE_KEY1, TEAMSET_1_ID, True),
('user2', COURSE_KEY1, TEAMSET_2_ID, False),
('user1', COURSE_KEY2, TEAMSET_1_ID, False),
('user2', COURSE_KEY2, TEAMSET_1_ID, False),
)
@ddt.unpack
def test_user_in_team_for_course_teamset(self, username, course_id,
teamset_id, expected_value):
user = getattr(self, username)
self.assertEqual(
CourseTeamMembership.user_in_team_for_course(
user, course_id, teamset_id), expected_value)
def setUpClass(cls):
# pylint: disable=no-member
super(TeamMembershipCsvTests, cls).setUpClass()
teams_config = TeamsConfig({
'team_sets': [
{
'id': 'teamset_{}'.format(i),
'name': 'teamset_{}_name'.format(i),
'description': 'teamset_{}_desc'.format(i),
}
for i in [1, 2, 3, 4]
]
})
cls.course = CourseFactory(teams_configuration=teams_config)
cls.course_no_teamsets = CourseFactory()
team1_1 = CourseTeamFactory(course_id=cls.course.id, name='team_1_1', topic_id='teamset_1')
CourseTeamFactory(course_id=cls.course.id, name='team_1_2', topic_id='teamset_1')
team2_1 = CourseTeamFactory(course_id=cls.course.id, name='team_2_1', topic_id='teamset_2')
team2_2 = CourseTeamFactory(course_id=cls.course.id, name='team_2_2', topic_id='teamset_2')
team3_1 = CourseTeamFactory(course_id=cls.course.id, name='team_3_1', topic_id='teamset_3')
# protected team
team3_2 = CourseTeamFactory(
course_id=cls.course.id,
name='team_3_2',
topic_id='teamset_3',
organization_protected=True
)
# No teams in teamset 4
user1 = UserFactory.create(username='******')
user2 = UserFactory.create(username='******')
user3 = UserFactory.create(username='******')
user4 = UserFactory.create(username='******')
user5 = UserFactory.create(username='******')
CourseEnrollmentFactory.create(user=user1, course_id=cls.course.id, mode='audit')
CourseEnrollmentFactory.create(user=user2, course_id=cls.course.id, mode='verified')
CourseEnrollmentFactory.create(user=user3, course_id=cls.course.id, mode='honors')
CourseEnrollmentFactory.create(user=user4, course_id=cls.course.id, mode='masters')
CourseEnrollmentFactory.create(user=user5, course_id=cls.course.id, mode='masters')
team1_1.add_user(user1)
team2_2.add_user(user1)
team3_1.add_user(user1)
team1_1.add_user(user2)
team2_2.add_user(user2)
team3_1.add_user(user2)
team2_1.add_user(user3)
team3_1.add_user(user3)
team3_2.add_user(user4)
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
)
