Python models.PersistentCourseGrade类代码示例

 def test_update(self):
     created_grade = PersistentCourseGrade.update_or_create_course_grade(**self.params)
     self.params["percent_grade"] = 88.8
     self.params["letter_grade"] = "Better job"
     updated_grade = PersistentCourseGrade.update_or_create_course_grade(**self.params)
     self.assertEqual(updated_grade.percent_grade, 88.8)
     self.assertEqual(updated_grade.letter_grade, "Better job")
     self.assertEqual(created_grade.id, updated_grade.id)

 def __init__(self, context, users):
     self.certs = _CertificateBulkContext(context, users)
     self.teams = _TeamBulkContext(context, users)
     self.enrollments = _EnrollmentBulkContext(context, users)
     bulk_cache_cohorts(context.course_id, users)
     BulkRoleCache.prefetch(users)
     PersistentCourseGrade.prefetch(context.course_id, users)
     BulkCourseTags.prefetch(context.course_id, users)

 def test_create_and_read_grade(self):
     created_grade = PersistentCourseGrade.update_or_create_course_grade(**self.params)
     read_grade = PersistentCourseGrade.read_course_grade(self.params["user_id"], self.params["course_id"])
     for param in self.params:
         if param == u'passed':
             continue  # passed/passed_timestamp takes special handling, and is tested separately
         self.assertEqual(self.params[param], getattr(created_grade, param))
     self.assertIsInstance(created_grade.passed_timestamp, datetime)
     self.assertEqual(created_grade, read_grade)

def bulk_course_grade_context(course_key, users):
    """
    Prefetches grades for the given users in the given course
    within a context, storing in a RequestCache and deleting
    on context exit.
    """
    PersistentCourseGrade.prefetch(course_key, users)
    yield
    PersistentCourseGrade.clear_prefetched_data(course_key)

 def test_persistent_grades_not_enabled_on_course(self, default_store, num_mongo_queries, num_sql_queries):
     with self.store.default_store(default_store):
         self.set_up_course(enable_persistent_grades=False)
         with check_mongo_calls(num_mongo_queries):
             with self.assertNumQueries(num_sql_queries):
                 self._apply_recalculate_subsection_grade()
         with self.assertRaises(PersistentCourseGrade.DoesNotExist):
             PersistentCourseGrade.read(self.user.id, self.course.id)
         self.assertEqual(len(PersistentSubsectionGrade.bulk_read_grades(self.user.id, self.course.id)), 0)

def bulk_gradebook_view_context(course_key, users):
    """
    Prefetches all course and subsection grades in the given course for the given
    list of users, also, fetch all the score relavant data,
    storing the result in a RequestCache and deleting grades on context exit.
    """
    PersistentSubsectionGrade.prefetch(course_key, users)
    PersistentCourseGrade.prefetch(course_key, users)
    CourseEnrollment.bulk_fetch_enrollment_states(users, course_key)
    cohorts.bulk_cache_cohorts(course_key, users)
    BulkRoleCache.prefetch(users)
    yield
    PersistentSubsectionGrade.clear_prefetched_data(course_key)
    PersistentCourseGrade.clear_prefetched_data(course_key)

 def test_persistent_grades_enabled_on_course(self, default_store, num_mongo_queries, num_sql_queries):
     with self.store.default_store(default_store):
         self.set_up_course(enable_persistent_grades=True)
         with check_mongo_calls(num_mongo_queries):
             with self.assertNumQueries(num_sql_queries):
                 self._apply_recalculate_subsection_grade()
         self.assertIsNotNone(PersistentCourseGrade.read(self.user.id, self.course.id))
         self.assertGreater(len(PersistentSubsectionGrade.bulk_read_grades(self.user.id, self.course.id)), 0)

    def test_passed_timestamp(self):
        # When the user has not passed, passed_timestamp is None
        self.params.update({
            u'percent_grade': 25.0,
            u'letter_grade': u'',
            u'passed': False,
        })
        grade = PersistentCourseGrade.update_or_create_course_grade(**self.params)
        self.assertIsNone(grade.passed_timestamp)

        # After the user earns a passing grade, the passed_timestamp is set
        self.params.update({
            u'percent_grade': 75.0,
            u'letter_grade': u'C',
            u'passed': True,
        })
        grade = PersistentCourseGrade.update_or_create_course_grade(**self.params)
        passed_timestamp = grade.passed_timestamp
        self.assertEqual(grade.letter_grade, u'C')
        self.assertIsInstance(passed_timestamp, datetime)

        # After the user improves their score, the new grade is reflected, but
        # the passed_timestamp remains the same.
        self.params.update({
            u'percent_grade': 95.0,
            u'letter_grade': u'A',
            u'passed': True,
        })
        grade = PersistentCourseGrade.update_or_create_course_grade(**self.params)
        self.assertEqual(grade.letter_grade, u'A')
        self.assertEqual(grade.passed_timestamp, passed_timestamp)

        # If the grade later reverts to a failing grade, they keep their passed_timestamp
        self.params.update({
            u'percent_grade': 20.0,
            u'letter_grade': u'',
            u'passed': False,
        })
        grade = PersistentCourseGrade.update_or_create_course_grade(**self.params)
        self.assertEqual(grade.letter_grade, u'')
        self.assertEqual(grade.passed_timestamp, passed_timestamp)

 def test_create_and_read_grade(self):
     created_grade = PersistentCourseGrade.update_or_create_course_grade(**self.params)
     read_grade = PersistentCourseGrade.read_course_grade(self.params["user_id"], self.params["course_id"])
     for param in self.params:
         self.assertEqual(self.params[param], getattr(created_grade, param))
     self.assertEqual(created_grade, read_grade)

def clear_prefetched_course_and_subsection_grades(course_key):
    _PersistentCourseGrade.clear_prefetched_data(course_key)

def prefetch_course_and_subsection_grades(course_key, users):
    _PersistentCourseGrade.prefetch(course_key, users)
    _PersistentSubsectionGrade.prefetch(course_key, users)

 def test_optional_fields(self, field):
     del self.params[field]
     grade = PersistentCourseGrade.update_or_create(**self.params)
     self.assertFalse(getattr(grade, field))

 def test_grade_does_not_exist(self):
     with self.assertRaises(PersistentCourseGrade.DoesNotExist):
         PersistentCourseGrade.read_course_grade(self.params["user_id"], self.params["course_id"])

 def test_update_or_create_with_bad_params(self, param, val, error):
     self.params[param] = val
     with self.assertRaises(error):
         PersistentCourseGrade.update_or_create_course_grade(**self.params)

 def test_passed_timestamp_is_now(self):
     grade = PersistentCourseGrade.update_or_create_course_grade(**self.params)
     self.assertEqual(now(), grade.passed_timestamp)