Grades: Clean up tests

EDUCATOR-1404

lms/djangoapps/grades/tests/base.py

+from capa.tests.response_xml_factory import MultipleChoiceResponseXMLFactory
+from lms.djangoapps.course_blocks.api import get_course_blocks
+from openedx.core.djangolib.testing.utils import get_mock_request
+from student.models import CourseEnrollment
+from student.tests.factories import UserFactory
+from xmodule.modulestore.tests.django_utils import SharedModuleStoreTestCase
+from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
+
+from ..subsection_grade_factory import SubsectionGradeFactory
+
+
+class GradeTestBase(SharedModuleStoreTestCase):
+    """
+    Base class for some Grades tests.
+    """
+    @classmethod
+    def setUpClass(cls):
+        super(GradeTestBase, cls).setUpClass()
+        cls.course = CourseFactory.create()
+        with cls.store.bulk_operations(cls.course.id):
+            cls.chapter = ItemFactory.create(
+                parent=cls.course,
+                category="chapter",
+                display_name="Test Chapter"
+            )
+            cls.sequence = ItemFactory.create(
+                parent=cls.chapter,
+                category='sequential',
+                display_name="Test Sequential 1",
+                graded=True,
+                format="Homework"
+            )
+            cls.vertical = ItemFactory.create(
+                parent=cls.sequence,
+                category='vertical',
+                display_name='Test Vertical 1'
+            )
+            problem_xml = MultipleChoiceResponseXMLFactory().build_xml(
+                question_text='The correct answer is Choice 3',
+                choices=[False, False, True, False],
+                choice_names=['choice_0', 'choice_1', 'choice_2', 'choice_3']
+            )
+            cls.problem = ItemFactory.create(
+                parent=cls.vertical,
+                category="problem",
+                display_name="Test Problem",
+                data=problem_xml
+            )
+            cls.sequence2 = ItemFactory.create(
+                parent=cls.chapter,
+                category='sequential',
+                display_name="Test Sequential 2",
+                graded=True,
+                format="Homework"
+            )
+            cls.problem2 = ItemFactory.create(
+                parent=cls.sequence2,
+                category="problem",
+                display_name="Test Problem",
+                data=problem_xml
+            )
+            # AED 2017-06-19: make cls.sequence belong to multiple parents,
+            # so we can test that DAGs with this shape are handled correctly.
+            cls.chapter_2 = ItemFactory.create(
+                parent=cls.course,
+                category='chapter',
+                display_name='Test Chapter 2'
+            )
+            cls.chapter_2.children.append(cls.sequence.location)
+            cls.store.update_item(cls.chapter_2, UserFactory().id)
+
+    def setUp(self):
+        super(GradeTestBase, self).setUp()
+        self.request = get_mock_request(UserFactory())
+        self.client.login(username=self.request.user.username, password="test")
+        self._set_grading_policy()
+        self.course_structure = get_course_blocks(self.request.user, self.course.location)
+        self.subsection_grade_factory = SubsectionGradeFactory(self.request.user, self.course, self.course_structure)
+        CourseEnrollment.enroll(self.request.user, self.course.id)
+
+    def _set_grading_policy(self, passing=0.5):
+        """
+        Updates the course's grading policy.
+        """
+        self.grading_policy = {
+            "GRADER": [
+                {
+                    "type": "Homework",
+                    "min_count": 1,
+                    "drop_count": 0,
+                    "short_label": "HW",
+                    "weight": 1.0,
+                },
+            ],
+            "GRADE_CUTOFFS": {
+                "Pass": passing,
+            },
+        }
+        self.course.set_grading_policy(self.grading_policy)
+        self.store.update_item(self.course, 0)

lms/djangoapps/grades/tests/test_course_grade.py

+import ddt
+from django.conf import settings
+from mock import patch
+
+from openedx.core.djangolib.testing.utils import get_mock_request
+from student.models import CourseEnrollment
+from student.tests.factories import UserFactory
+from xmodule.modulestore.tests.django_utils import SharedModuleStoreTestCase
+from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
+
+from ..config.waffle import ASSUME_ZERO_GRADE_IF_ABSENT, waffle
+from ..course_data import CourseData
+from ..course_grade import ZeroCourseGrade
+from ..course_grade_factory import CourseGradeFactory
+from .base import GradeTestBase
+from .utils import answer_problem
+
+
+@patch.dict(settings.FEATURES, {'ASSUME_ZERO_GRADE_IF_ABSENT_FOR_ALL_TESTS': False})
+@ddt.ddt
+class ZeroGradeTest(GradeTestBase):
+    """
+    Tests ZeroCourseGrade (and, implicitly, ZeroSubsectionGrade)
+    functionality.
+    """
+    @ddt.data(True, False)
+    def test_zero(self, assume_zero_enabled):
+        """
+        Creates a ZeroCourseGrade and ensures it's empty.
+        """
+        with waffle().override(ASSUME_ZERO_GRADE_IF_ABSENT, active=assume_zero_enabled):
+            course_data = CourseData(self.request.user, structure=self.course_structure)
+            chapter_grades = ZeroCourseGrade(self.request.user, course_data).chapter_grades
+            for chapter in chapter_grades:
+                for section in chapter_grades[chapter]['sections']:
+                    for score in section.problem_scores.itervalues():
+                        self.assertEqual(score.earned, 0)
+                        self.assertEqual(score.first_attempted, None)
+                    self.assertEqual(section.all_total.earned, 0)
+
+    @ddt.data(True, False)
+    def test_zero_null_scores(self, assume_zero_enabled):
+        """
+        Creates a zero course grade and ensures that null scores aren't included in the section problem scores.
+        """
+        with waffle().override(ASSUME_ZERO_GRADE_IF_ABSENT, active=assume_zero_enabled):
+            with patch('lms.djangoapps.grades.subsection_grade.get_score', return_value=None):
+                course_data = CourseData(self.request.user, structure=self.course_structure)
+                chapter_grades = ZeroCourseGrade(self.request.user, course_data).chapter_grades
+                for chapter in chapter_grades:
+                    self.assertNotEqual({}, chapter_grades[chapter]['sections'])
+                    for section in chapter_grades[chapter]['sections']:
+                        self.assertEqual({}, section.problem_scores)
+
+
+class TestScoreForModule(SharedModuleStoreTestCase):
+    """
+    Test the method that calculates the score for a given block based on the
+    cumulative scores of its children. This test class uses a hard-coded block
+    hierarchy with scores as follows:
+                                                a
+                                       +--------+--------+
+                                       b                 c
+                        +--------------+-----------+     |
+                        d              e           f     g
+                     +-----+     +-----+-----+     |     |
+                     h     i     j     k     l     m     n
+                   (2/5) (3/5) (0/1)   -   (1/3)   -   (3/10)
+
+    """
+    @classmethod
+    def setUpClass(cls):
+        super(TestScoreForModule, cls).setUpClass()
+        cls.course = CourseFactory.create()
+        with cls.store.bulk_operations(cls.course.id):
+            cls.a = ItemFactory.create(parent=cls.course, category="chapter", display_name="a")
+            cls.b = ItemFactory.create(parent=cls.a, category="sequential", display_name="b")
+            cls.c = ItemFactory.create(parent=cls.a, category="sequential", display_name="c")
+            cls.d = ItemFactory.create(parent=cls.b, category="vertical", display_name="d")
+            cls.e = ItemFactory.create(parent=cls.b, category="vertical", display_name="e")
+            cls.f = ItemFactory.create(parent=cls.b, category="vertical", display_name="f")
+            cls.g = ItemFactory.create(parent=cls.c, category="vertical", display_name="g")
+            cls.h = ItemFactory.create(parent=cls.d, category="problem", display_name="h")
+            cls.i = ItemFactory.create(parent=cls.d, category="problem", display_name="i")
+            cls.j = ItemFactory.create(parent=cls.e, category="problem", display_name="j")
+            cls.k = ItemFactory.create(parent=cls.e, category="html", display_name="k")
+            cls.l = ItemFactory.create(parent=cls.e, category="problem", display_name="l")
+            cls.m = ItemFactory.create(parent=cls.f, category="html", display_name="m")
+            cls.n = ItemFactory.create(parent=cls.g, category="problem", display_name="n")
+
+        cls.request = get_mock_request(UserFactory())
+        CourseEnrollment.enroll(cls.request.user, cls.course.id)
+
+        answer_problem(cls.course, cls.request, cls.h, score=2, max_value=5)
+        answer_problem(cls.course, cls.request, cls.i, score=3, max_value=5)
+        answer_problem(cls.course, cls.request, cls.j, score=0, max_value=1)
+        answer_problem(cls.course, cls.request, cls.l, score=1, max_value=3)
+        answer_problem(cls.course, cls.request, cls.n, score=3, max_value=10)
+
+        cls.course_grade = CourseGradeFactory().read(cls.request.user, cls.course)
+
+    def test_score_chapter(self):
+        earned, possible = self.course_grade.score_for_module(self.a.location)
+        self.assertEqual(earned, 9)
+        self.assertEqual(possible, 24)
+
+    def test_score_section_many_leaves(self):
+        earned, possible = self.course_grade.score_for_module(self.b.location)
+        self.assertEqual(earned, 6)
+        self.assertEqual(possible, 14)
+
+    def test_score_section_one_leaf(self):
+        earned, possible = self.course_grade.score_for_module(self.c.location)
+        self.assertEqual(earned, 3)
+        self.assertEqual(possible, 10)
+
+    def test_score_vertical_two_leaves(self):
+        earned, possible = self.course_grade.score_for_module(self.d.location)
+        self.assertEqual(earned, 5)
+        self.assertEqual(possible, 10)
+
+    def test_score_vertical_two_leaves_one_unscored(self):
+        earned, possible = self.course_grade.score_for_module(self.e.location)
+        self.assertEqual(earned, 1)
+        self.assertEqual(possible, 4)
+
+    def test_score_vertical_no_score(self):
+        earned, possible = self.course_grade.score_for_module(self.f.location)
+        self.assertEqual(earned, 0)
+        self.assertEqual(possible, 0)
+
+    def test_score_vertical_one_leaf(self):
+        earned, possible = self.course_grade.score_for_module(self.g.location)
+        self.assertEqual(earned, 3)
+        self.assertEqual(possible, 10)
+
+    def test_score_leaf(self):
+        earned, possible = self.course_grade.score_for_module(self.h.location)
+        self.assertEqual(earned, 2)
+        self.assertEqual(possible, 5)
+
+    def test_score_leaf_no_score(self):
+        earned, possible = self.course_grade.score_for_module(self.m.location)
+        self.assertEqual(earned, 0)
+        self.assertEqual(possible, 0)

lms/djangoapps/grades/tests/test_subsection_grade.py

+from ..models import PersistentSubsectionGrade
+from ..subsection_grade import SubsectionGrade
+from .utils import mock_get_score
+from .base import  GradeTestBase
+
+
+class SubsectionGradeTest(GradeTestBase):
+    def test_save_and_load(self):
+        with mock_get_score(1, 2):
+            # Create a grade that *isn't* saved to the database
+            input_grade = SubsectionGrade(self.sequence)
+            input_grade.init_from_structure(
+                self.request.user,
+                self.course_structure,
+                self.subsection_grade_factory._submissions_scores,
+                self.subsection_grade_factory._csm_scores,
+            )
+            self.assertEqual(PersistentSubsectionGrade.objects.count(), 0)
+
+            # save to db, and verify object is in database
+            input_grade.create_model(self.request.user)
+            self.assertEqual(PersistentSubsectionGrade.objects.count(), 1)
+
+            # load from db, and ensure output matches input
+            loaded_grade = SubsectionGrade(self.sequence)
+            saved_model = PersistentSubsectionGrade.read_grade(
+                user_id=self.request.user.id,
+                usage_key=self.sequence.location,
+            )
+            loaded_grade.init_from_model(
+                self.request.user,
+                saved_model,
+                self.course_structure,
+                self.subsection_grade_factory._submissions_scores,
+                self.subsection_grade_factory._csm_scores,
+            )
+
+            self.assertEqual(input_grade.url_name, loaded_grade.url_name)
+            loaded_grade.all_total.first_attempted = input_grade.all_total.first_attempted = None
+            self.assertEqual(input_grade.all_total, loaded_grade.all_total)

lms/djangoapps/grades/tests/test_subsection_grade_factory.py

+import ddt
+from courseware.tests.test_submitting_problems import ProblemSubmissionTestMixin
+from django.conf import settings
+from lms.djangoapps.grades.config.tests.utils import persistent_grades_feature_flags
+from mock import patch
+
+from ..models import PersistentSubsectionGrade
+from ..subsection_grade_factory import ZeroSubsectionGrade
+from .base import GradeTestBase
+from .utils import mock_get_score
+
+
+@ddt.ddt
+class TestSubsectionGradeFactory(ProblemSubmissionTestMixin, GradeTestBase):
+    """
+    Tests for SubsectionGradeFactory functionality.
+
+    Ensures that SubsectionGrades are created and updated properly, that
+    persistent grades are functioning as expected, and that the flag to
+    enable saving subsection grades blocks/enables that feature as expected.
+    """
+
+    def assert_grade(self, grade, expected_earned, expected_possible):
+        """
+        Asserts that the given grade object has the expected score.
+        """
+        self.assertEqual(
+            (grade.all_total.earned, grade.all_total.possible),
+            (expected_earned, expected_possible),
+        )
+
+    def test_create_zero(self):
+        """
+        Test that a zero grade is returned.
+        """
+        grade = self.subsection_grade_factory.create(self.sequence)
+        self.assertIsInstance(grade, ZeroSubsectionGrade)
+        self.assert_grade(grade, 0.0, 1.0)
+
+    def test_update(self):
+        """
+        Assuming the underlying score reporting methods work,
+        test that the score is calculated properly.
+        """
+        with mock_get_score(1, 2):
+            grade = self.subsection_grade_factory.update(self.sequence)
+        self.assert_grade(grade, 1, 2)
+
+    def test_write_only_if_engaged(self):
+        """
+        Test that scores are not persisted when a learner has
+        never attempted a problem, but are persisted if the
+        learner's state has been deleted.
+        """
+        with mock_get_score(0, 0, None):
+            self.subsection_grade_factory.update(self.sequence)
+        # ensure no grades have been persisted
+        self.assertEqual(0, len(PersistentSubsectionGrade.objects.all()))
+
+        with mock_get_score(0, 0, None):
+            self.subsection_grade_factory.update(self.sequence, score_deleted=True)
+        # ensure a grade has been persisted
+        self.assertEqual(1, len(PersistentSubsectionGrade.objects.all()))
+
+    def test_update_if_higher(self):
+        def verify_update_if_higher(mock_score, expected_grade):
+            """
+            Updates the subsection grade and verifies the
+            resulting grade is as expected.
+            """
+            with mock_get_score(*mock_score):
+                grade = self.subsection_grade_factory.update(self.sequence, only_if_higher=True)
+                self.assert_grade(grade, *expected_grade)
+
+        verify_update_if_higher((1, 2), (1, 2))  # previous value was non-existent
+        verify_update_if_higher((2, 4), (2, 4))  # previous value was equivalent
+        verify_update_if_higher((1, 4), (2, 4))  # previous value was greater
+        verify_update_if_higher((3, 4), (3, 4))  # previous value was less
+
+    @patch.dict(settings.FEATURES, {'PERSISTENT_GRADES_ENABLED_FOR_ALL_TESTS': False})
+    @ddt.data(
+        (True, True),
+        (True, False),
+        (False, True),
+        (False, False),
+    )
+    @ddt.unpack
+    def test_subsection_grade_feature_gating(self, feature_flag, course_setting):
+        # Grades are only saved if the feature flag and the advanced setting are
+        # both set to True.
+        with patch(
+            'lms.djangoapps.grades.models.PersistentSubsectionGrade.bulk_read_grades'
+        ) as mock_read_saved_grade:
+            with persistent_grades_feature_flags(
+                global_flag=feature_flag,
+                enabled_for_all_courses=False,
+                course_id=self.course.id,
+                enabled_for_course=course_setting
+            ):
+                self.subsection_grade_factory.create(self.sequence)
+        self.assertEqual(mock_read_saved_grade.called, feature_flag and course_setting)