def set_weighted_policy(self, hw_weight=0.25, final_weight=0.75):
"""
Set up a simple course for testing weighted grading functionality.
"""
grading_policy = {
"GRADER": [
{
"type": "Homework",
"min_count": 1,
"drop_count": 0,
"short_label": "HW",
"weight": hw_weight
},
{
"type": "Final",
"min_count": 0,
"drop_count": 0,
"name": "Final Section",
"short_label": "Final",
"weight": final_weight
}
]
}
self.add_grading_policy(grading_policy)
compute_all_grades_for_course.apply_async(kwargs={'course_key': unicode(self.course.id)})
def set_weighted_policy(self, hw_weight=0.25, final_weight=0.75):
"""
Set up a simple course for testing weighted grading functionality.
"""
grading_policy = {
"GRADER": [
{
"type": "Homework",
"min_count": 1,
"drop_count": 0,
"short_label": "HW",
"weight": hw_weight
},
{
"type": "Final",
"min_count": 0,
"drop_count": 0,
"name": "Final Section",
"short_label": "Final",
"weight": final_weight
}
]
}
self.add_grading_policy(grading_policy)
compute_all_grades_for_course.apply_async(kwargs={'course_key': unicode(self.course.id)})
def setUp(self):
super(TestGradebook, self).setUp()
instructor = AdminFactory.create()
self.client.login(username=instructor.username, password='******')
self.users = [UserFactory.create() for _ in xrange(USER_COUNT)]
for user in self.users:
CourseEnrollmentFactory.create(user=user, course_id=self.course.id)
for i, item in enumerate(self.items):
for j, user in enumerate(self.users):
StudentModuleFactory.create(
grade=1 if i < j else 0,
max_grade=1,
student=user,
course_id=self.course.id,
module_state_key=item.location
)
compute_all_grades_for_course.apply_async(kwargs={'course_key': text_type(self.course.id)})
self.response = self.client.get(reverse(
'spoc_gradebook',
args=(text_type(self.course.id),)
))
self.assertEquals(self.response.status_code, 200)
def setUp(self):
super(TestGradebook, self).setUp()
instructor = AdminFactory.create()
self.client.login(username=instructor.username, password='******')
self.users = [UserFactory.create() for _ in xrange(USER_COUNT)]
for user in self.users:
CourseEnrollmentFactory.create(user=user, course_id=self.course.id)
for i, item in enumerate(self.items):
for j, user in enumerate(self.users):
StudentModuleFactory.create(
grade=1 if i < j else 0,
max_grade=1,
student=user,
course_id=self.course.id,
module_state_key=item.location
)
compute_all_grades_for_course.apply_async(kwargs={'course_key': text_type(self.course.id)})
self.response = self.client.get(reverse(
'spoc_gradebook',
args=(text_type(self.course.id),)
))
self.assertEquals(self.response.status_code, 200)
def handle_grading_policy_changed(sender, **kwargs):
# pylint: disable=unused-argument
"""
Receives signal and kicks off celery task to recalculate grades
"""
kwargs = {
'course_key': unicode(kwargs.get('course_key')),
'event_transaction_id': unicode(get_event_transaction_id()),
'event_transaction_type': unicode(get_event_transaction_type()),
}
result = compute_all_grades_for_course.apply_async(kwargs=kwargs)
log.info("Grades: Created {task_name}[{task_id}] with arguments {kwargs}".format(
task_name=compute_all_grades_for_course.name,
task_id=result.task_id,
kwargs=kwargs,
))
def handle_grading_policy_changed(sender, **kwargs):
# pylint: disable=unused-argument
"""
Receives signal and kicks off celery task to recalculate grades
"""
course_key = kwargs.get('course_key')
result = compute_all_grades_for_course.apply_async(
course_key=course_key,
event_transaction_id=get_event_transaction_id(),
event_transaction_type=get_event_transaction_type(),
)
log.info("Grades: Created {task_name}[{task_id}] with arguments {kwargs}".format(
task_name=compute_all_grades_for_course.name,
task_id=result.task_id,
kwargs=kwargs,
))
def handle_grading_policy_changed(sender, **kwargs):
# pylint: disable=unused-argument
"""
Receives signal and kicks off celery task to recalculate grades
"""
kwargs = {
'course_key': unicode(kwargs.get('course_key')),
'event_transaction_id': unicode(get_event_transaction_id()),
'event_transaction_type': unicode(get_event_transaction_type()),
}
result = compute_all_grades_for_course.apply_async(kwargs=kwargs, countdown=GRADING_POLICY_COUNTDOWN_SECONDS)
log.info("Grades: Created {task_name}[{task_id}] with arguments {kwargs}".format(
task_name=compute_all_grades_for_course.name,
task_id=result.task_id,
kwargs=kwargs,
))
def test_compute_all_grades_for_course(self, freeze_flag_value,
end_date_adjustment, mock_log):
self.set_up_course(course_end=timezone.now() -
timedelta(end_date_adjustment))
for user in self.users:
CourseEnrollment.enroll(user, self.course.id)
with override_waffle_flag(self.freeze_grade_flag,
active=freeze_flag_value):
with patch(
'lms.djangoapps.grades.tasks.compute_grades_for_course_v2.apply_async',
return_value=None) as mock_compute_grades:
result = compute_all_grades_for_course.apply_async(
kwargs={'course_key': six.text_type(self.course.id)})
self._assert_for_freeze_grade_flag(
result, freeze_flag_value, end_date_adjustment, mock_log,
mock_compute_grades, 'compute_all_grades_for_course')
def test_compute_all_grades_for_course(self, freeze_flag_value, end_date_adjustment, mock_log):
self.set_up_course(course_end=timezone.now() - timedelta(end_date_adjustment))
for user in self.users:
CourseEnrollment.enroll(user, self.course.id)
with override_waffle_flag(self.freeze_grade_flag, active=freeze_flag_value):
with patch(
'lms.djangoapps.grades.tasks.compute_grades_for_course_v2.apply_async',
return_value=None
) as mock_compute_grades:
result = compute_all_grades_for_course.apply_async(
kwargs={
'course_key': six.text_type(self.course.id)
}
)
self._assert_for_freeze_grade_flag(
result,
freeze_flag_value,
end_date_adjustment,
mock_log,
mock_compute_grades,
'compute_all_grades_for_course'
)
def setUp(self):
super(TestStaffView, self).setUp()
# create a course
self.course = CourseFactory.create(org='mss',
course='999',
display_name='eol feedback course')
# Now give it some content
with self.store.bulk_operations(self.course.id, emit_signals=False):
chapter = ItemFactory.create(
parent_location=self.course.location,
category="sequential",
)
section = ItemFactory.create(parent_location=chapter.location,
category="sequential",
metadata={
'graded': True,
'format': 'Homework'
})
self.items = [
ItemFactory.create(
parent_location=section.location,
category="problem",
data=StringResponseXMLFactory().build_xml(answer='foo'),
metadata={'rerandomize': 'always'})
for __ in range(USER_COUNT - 1)
]
# Create users, enroll and set grades
self.users = [UserFactory.create() for _ in range(USER_COUNT)]
for user in self.users:
CourseEnrollmentFactory.create(user=user, course_id=self.course.id)
for i, item in enumerate(self.items):
for j, user in enumerate(self.users):
StudentModuleFactory.create(grade=1 if i < j else 0,
max_grade=1,
student=user,
course_id=self.course.id,
module_state_key=item.location)
task_compute_all_grades_for_course.apply_async(
kwargs={'course_key': text_type(self.course.id)})
# Patch the comment client user save method so it does not try
# to create a new cc user when creating a django user
with patch('student.models.cc.User.save'):
# Create the student
self.student = UserFactory(username='******',
password='******',
email='*****@*****.**')
# Enroll the student in the course
CourseEnrollmentFactory(user=self.student,
course_id=self.course.id)
# Create and Enroll staff user
self.staff_user = UserFactory(username='******',
password='******',
email='*****@*****.**',
is_staff=True)
CourseEnrollmentFactory(user=self.staff_user,
course_id=self.course.id)
# Log the student in
self.client = Client()
self.assertTrue(
self.client.login(username='******', password='******'))
# Log the user staff in
self.staff_client = Client()
self.assertTrue(
self.staff_client.login(username='******',
password='******'))
