def setUp(self): super(EntitlementViewSetTest, self).setUp() self.user = UserFactory(is_staff=True) self.client.login(username=self.user.username, password=TEST_PASSWORD) self.course = CourseFactory() self.entitlements_list_url = reverse('entitlements_api:v1:entitlements-list')
def setUpClass(cls): super().setUpClass() cls.course = CourseFactory(default_store=ModuleStoreEnum.Type.split) cls.course_key = cls.course.id # pylint: disable=no-member
def setUpClass(cls): super().setUpClass() cls.course = CourseFactory() cls.other_course = CourseFactory() cls.user = UserFactory() cls.instructor = UserFactory(username='******', is_staff=True)
def setUp(self): super().setUp() self.course = CourseFactory(enable_proctored_exams=True) self.user = UserFactory()
def test_course_enrollment_closed_past(self): start = self.now - datetime.timedelta(days=2) end = self.now - datetime.timedelta(days=1) course = CourseFactory(enrollment_start=start, enrollment_end=end) self.assertFalse(course_open_for_self_enrollment(course.id))
def test_nonexistent_course_404(self): CourseFactory() response = self.client.get('/mock/course-v1:Non+Existent+Course/') assert response.status_code == 404
def setUpClass(cls): super(TestManualEnrollmentAudit, cls).setUpClass() cls.course = CourseFactory() cls.other_course = CourseFactory() cls.user = UserFactory() cls.instructor = UserFactory(username='******', is_staff=True)
def setUpClass(cls): super(CookieTests, cls).setUpClass() cls.course = CourseFactory()
def setUp(self): super(TestMigrateToSplit, self).setUp(create_user=True) self.course = CourseFactory()
def setUp(self): super(TestCourseUpdateResolver, self).setUp() self.course = CourseFactory(highlights_enabled_for_messaging=True, self_paced=True) with self.store.bulk_operations(self.course.id): ItemFactory.create(parent=self.course, category='chapter', highlights=[u'good stuff'])
def test_retrieve(self): course_run = CourseFactory() url = reverse('api:v1:course_run-detail', kwargs={'pk': str(course_run.id)}) response = self.client.get(url) assert response.status_code == 200 assert response.data == CourseRunSerializer(course_run, context=self.get_serializer_context()).data
def test_course_enrollment_closed_future(self): start = self.now + datetime.timedelta(days=1) end = self.now + datetime.timedelta(days=2) course = CourseFactory(enrollment_start=start, enrollment_end=end) assert not course_open_for_self_enrollment(course.id)
def setUp(self): super(TestMigrateToSplit, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments self.course = CourseFactory(default_store=ModuleStoreEnum.Type.mongo)
def setUp(self): super().setUp() self.course = CourseFactory(default_store=ModuleStoreEnum.Type.mongo)
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)
def _multisetup(self): """ setup certs across two course runs """ course_run = CourseFactory() course_run_key = course_run.id course_run2 = CourseFactory() course_run_key2 = course_run2.id user = UserFactory() CourseEnrollmentFactory( user=user, course_id=course_run_key, is_active=True, mode=CourseMode.VERIFIED, ) GeneratedCertificateFactory(user=user, course_id=course_run_key, mode=GeneratedCertificate.MODES.verified, status=CertificateStatuses.unverified) user1 = UserFactory() CourseEnrollmentFactory( user=user1, course_id=course_run_key, is_active=True, mode=CourseMode.VERIFIED, ) GeneratedCertificateFactory(user=user1, course_id=course_run_key, mode=GeneratedCertificate.MODES.verified, status=CertificateStatuses.unverified) user2 = UserFactory() CourseEnrollmentFactory( user=user2, course_id=course_run_key2, is_active=True, mode=CourseMode.VERIFIED, ) GeneratedCertificateFactory(user=user2, course_id=course_run_key2, mode=GeneratedCertificate.MODES.verified, status=CertificateStatuses.unverified) user_verified = UserFactory() CourseEnrollmentFactory( user=user_verified, course_id=course_run_key, is_active=True, mode=CourseMode.VERIFIED, ) GeneratedCertificateFactory(user=user_verified, course_id=course_run_key, mode=GeneratedCertificate.MODES.verified, status=CertificateStatuses.downloadable) user_failing = UserFactory() CourseEnrollmentFactory( user=user_failing, course_id=course_run_key2, is_active=True, mode=CourseMode.VERIFIED, ) GeneratedCertificateFactory(user=user_failing, course_id=course_run_key2, mode=GeneratedCertificate.MODES.verified, status=CertificateStatuses.notpassing) return (course_run_key, course_run_key2)
def setUpClass(cls): super(TestProgramDetails, cls).setUpClass() cls.course = CourseFactory()
def setUpClass(cls): super(PythonAPITests, cls).setUpClass() cls.user1 = UserFactory.create(username='******') cls.user2 = UserFactory.create(username='******') cls.user3 = UserFactory.create(username='******') cls.user4 = UserFactory.create(username='******') topic_data = [(TOPIC1, TeamsetType.private_managed.value), (TOPIC2, TeamsetType.open.value), (TOPIC3, TeamsetType.public_managed.value)] topics = [{ 'id': topic_id, 'name': 'name-' + topic_id, 'description': 'desc-' + topic_id, 'type': teamset_type } for topic_id, teamset_type in topic_data] teams_config_1 = TeamsConfig({'topics': [topics[0]]}) teams_config_2 = TeamsConfig({'topics': [topics[1], topics[2]]}) cls.course1 = CourseFactory( org=COURSE_KEY1.org, course=COURSE_KEY1.course, run=COURSE_KEY1.run, teams_configuration=teams_config_1, ) cls.course2 = CourseFactory( org=COURSE_KEY2.org, course=COURSE_KEY2.course, run=COURSE_KEY2.run, teams_configuration=teams_config_2, ) for user in (cls.user1, cls.user2, cls.user3, cls.user4): CourseEnrollmentFactory.create(user=user, course_id=COURSE_KEY1) for user in (cls.user3, cls.user4): CourseEnrollmentFactory.create(user=user, course_id=COURSE_KEY2) cls.team1 = CourseTeamFactory( course_id=COURSE_KEY1, discussion_topic_id=DISCUSSION_TOPIC_ID, team_id='team1', topic_id=TOPIC1, ) cls.team1a = CourseTeamFactory( # Same topic / team set as team1 course_id=COURSE_KEY1, team_id='team1a', topic_id=TOPIC1, ) cls.team2 = CourseTeamFactory(course_id=COURSE_KEY2, team_id='team2', topic_id=TOPIC2) cls.team2a = CourseTeamFactory( # Same topic / team set as team2 course_id=COURSE_KEY2, team_id='team2a', topic_id=TOPIC2) cls.team3 = CourseTeamFactory(course_id=COURSE_KEY2, team_id='team3', topic_id=TOPIC3) cls.team1.add_user(cls.user1) cls.team1.add_user(cls.user2) cls.team2.add_user(cls.user3) cls.team1a.add_user(cls.user4) cls.team2a.add_user(cls.user4)
def setUpClass(cls): super(CourseEnrollmentTests, cls).setUpClass() cls.course = CourseFactory()
def setUpClass(cls): super(RelatedProgramsTests, cls).setUpClass() cls.user = UserFactory() cls.course = CourseFactory() cls.enrollment = CourseEnrollmentFactory(user=cls.user, course_id=cls.course.id) # pylint: disable=no-member
def course_key(self): return CourseFactory().id # lint-amnesty, pylint: disable=no-member
def setUp(self): super(TestRollbackSplitCourseNoSplitMongo, self).setUp() self.old_course = CourseFactory()
def test_course_enrollment_open(self): start = self.now - datetime.timedelta(days=1) end = self.now + datetime.timedelta(days=1) course = CourseFactory(enrollment_start=start, enrollment_end=end) self.assertTrue(course_open_for_self_enrollment(course.id))
def setUp(self): super(CreateVerificationPartitionTest, self).setUp() # Disconnect the signal receiver -- we'll invoke the update code ourselves SignalHandler.pre_publish.disconnect(receiver=on_pre_publish) self.addCleanup(SignalHandler.pre_publish.connect, receiver=on_pre_publish) # Create a dummy course with a single verification checkpoint # Because we need to check "exam" content surrounding the ICRV checkpoint, # we need to create a fairly large course structure, with multiple sections, # subsections, verticals, units, and items. self.course = CourseFactory() self.sections = [ ItemFactory.create(parent=self.course, category='chapter', display_name='Test Section A'), ItemFactory.create(parent=self.course, category='chapter', display_name='Test Section B'), ] self.subsections = [ ItemFactory.create(parent=self.sections[0], category='sequential', display_name='Test Subsection A 1'), ItemFactory.create(parent=self.sections[0], category='sequential', display_name='Test Subsection A 2'), ItemFactory.create(parent=self.sections[1], category='sequential', display_name='Test Subsection B 1'), ItemFactory.create(parent=self.sections[1], category='sequential', display_name='Test Subsection B 2'), ] self.verticals = [ ItemFactory.create(parent=self.subsections[0], category='vertical', display_name='Test Unit A 1 a'), ItemFactory.create(parent=self.subsections[0], category='vertical', display_name='Test Unit A 1 b'), ItemFactory.create(parent=self.subsections[1], category='vertical', display_name='Test Unit A 2 a'), ItemFactory.create(parent=self.subsections[1], category='vertical', display_name='Test Unit A 2 b'), ItemFactory.create(parent=self.subsections[2], category='vertical', display_name='Test Unit B 1 a'), ItemFactory.create(parent=self.subsections[2], category='vertical', display_name='Test Unit B 1 b'), ItemFactory.create(parent=self.subsections[3], category='vertical', display_name='Test Unit B 2 a'), ItemFactory.create(parent=self.subsections[3], category='vertical', display_name='Test Unit B 2 b'), ] self.icrv = ItemFactory.create(parent=self.verticals[0], category='edx-reverification-block') self.sibling_problem = ItemFactory.create(parent=self.verticals[0], category='problem')
def test_course_enrollment_dates_missing(self): course = CourseFactory() self.assertTrue(course_open_for_self_enrollment(course.id))
def setUpClass(cls): super(EligibleCertificateManagerTest, cls).setUpClass() cls.courses = (CourseFactory(), CourseFactory())
def setUpClass(cls): super().setUpClass() cls.course = CourseFactory()
def course_key(self): return CourseFactory().id
def setUp(self): super(TestMigrateToSplit, self).setUp() self.course = CourseFactory(default_store=ModuleStoreEnum.Type.mongo)
def setUpClass(cls): super(PendingEmailChangeTests, cls).setUpClass() cls.course = CourseFactory() cls.user = UserFactory() cls.user2 = UserFactory()