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 )