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()