fix: enable extracted problem block tests

Author: irtazaakram

lms/djangoapps/courseware/tests/test_submitting_problems.py

@@ -4,7 +4,7 @@
 
 # pylint: disable=attribute-defined-outside-init
 
-
+from xmodule.capa_block import reset_class  # pylint: disable=wrong-import-order
 import json
 import os
 from datetime import datetime
@@ -18,6 +18,7 @@
 from django.db import connections
 from django.test import TestCase
 from django.test.client import RequestFactory
+from django.test.utils import override_settings
 from django.urls import reverse
 from django.utils.timezone import now
 from submissions import api as submissions_api
@@ -44,10 +45,16 @@
 from xmodule.partitions.partitions import Group, UserPartition  # lint-amnesty, pylint: disable=wrong-import-order
 
 
-class ProblemSubmissionTestMixin(TestCase):
+class BaseProblemSubmissionTestMixin(TestCase):
     """
     TestCase mixin that provides functions to submit answers to problems.
     """
+    __test__ = False
+
+    def setUp(self):
+        reset_class()
+        super().setUp()
+
     def refresh_course(self):
         """
         Re-fetch the course from the database so that the object being dealt with has everything added to it.
@@ -135,7 +142,19 @@ def show_question_answer(self, problem_url_name):
         return resp
 
 
-class TestSubmittingProblems(ModuleStoreTestCase, LoginEnrollmentTestCase, ProblemSubmissionTestMixin):
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=False)
+class ProblemSubmissionTestMixinBuiltin(BaseProblemSubmissionTestMixin):
+    """Run tests against the built-in problem block."""
+    __test__ = True
+
+
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=True)
+class ProblemSubmissionTestMixinExtracted(BaseProblemSubmissionTestMixin):
+    """Run tests against the extracted problem block."""
+    __test__ = True
+
+
+class BaseTestSubmittingProblems(ModuleStoreTestCase, LoginEnrollmentTestCase, BaseProblemSubmissionTestMixin):
     """
     Check that a course gets graded properly.
     """
@@ -149,7 +168,10 @@ class TestSubmittingProblems(ModuleStoreTestCase, LoginEnrollmentTestCase, Probl
     ENABLED_CACHES = ['default', 'mongo_metadata_inheritance', 'loc_cache']
     ENABLED_SIGNALS = ['course_published']
 
+    __test__ = False
+
     def setUp(self):
+        reset_class()
         super().setUp()
 
         # create a test student
@@ -306,11 +328,26 @@ def score_for_hw(self, hw_url_name):
         return [s.earned for s in self.hw_grade(hw_url_name).problem_scores.values()]
 
 
-class TestCourseGrades(TestSubmittingProblems):
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=False)
+class TestSubmittingProblemsBuiltin(BaseTestSubmittingProblems):
+    """Run tests against the built-in problem block."""
+    __test__ = True
+
+
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=True)
+class TestSubmittingProblemsExtracted(BaseTestSubmittingProblems):
+    """Run tests against the extracted problem block."""
+    __test__ = True
+
+
+class BaseTestCourseGrades(BaseTestSubmittingProblems):
     """
     Tests grades are updated correctly when manipulating problems.
     """
+    __test__ = False
+
     def setUp(self):
+        reset_class()
         super().setUp()
         self.homework = self.add_graded_section_to_course('homework')
         self.problem = self.add_dropdown_to_section(self.homework.location, 'p1', 1)
@@ -341,13 +378,30 @@ def test_problem_reset(self):
         self._verify_grade(expected_problem_score=(0.0, 1.0), expected_hw_grade=(0.0, 1.0))
 
 
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=False)
+class TestCourseGradesBuiltin(BaseTestCourseGrades):
+    """Run tests against the built-in problem block."""
+    __test__ = True
+
+
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=True)
+class TestCourseGradesExtracted(BaseTestCourseGrades):
+    """Run tests against the extracted problem block."""
+    __test__ = True
+
+
 @ddt.ddt
-class TestCourseGrader(TestSubmittingProblems):
+class BaseTestCourseGrader(BaseTestSubmittingProblems):
     """
     Suite of tests for the course grader.
     """
     # Tell Django to clean out all databases, not just default
     databases = set(connections)
+    __test__ = False
+
+    def setUp(self):
+        reset_class()
+        super().setUp()
 
     def basic_setup(self, late=False, reset=False, showanswer=False):
         """
@@ -757,12 +811,27 @@ def test_min_grade_credit_requirements_status(self, mode):
         assert req_status[0]['status'] == 'satisfied'
 
 
-class ProblemWithUploadedFilesTest(TestSubmittingProblems):
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=False)
+class TestCourseGraderBuiltin(BaseTestCourseGrader):
+    """Run tests against the built-in problem block."""
+    __test__ = True
+
+
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=True)
+class TestCourseGraderExtracted(BaseTestCourseGrader):
+    """Run tests against the extracted problem block."""
+    __test__ = True
+
+
+class BaseProblemWithUploadedFilesTest(BaseTestSubmittingProblems):
     """Tests of problems with uploaded files."""
     # Tell Django to clean out all databases, not just default
     databases = set(connections)
 
+    __test__ = False
+
     def setUp(self):
+        reset_class()
         super().setUp()
         self.section = self.add_graded_section_to_course('section')
 
@@ -811,8 +880,20 @@ def test_three_files(self, mock_xqueue_post):
         self.assertEqual(list(kwargs['files'].keys()), filenames.split())
 
 
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=False)
+class ProblemWithUploadedFilesTestBuiltin(BaseProblemWithUploadedFilesTest):
+    """Run tests against the built-in problem block."""
+    __test__ = True
+
+
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=True)
+class ProblemWithUploadedFilesTestExtracted(BaseProblemWithUploadedFilesTest):
+    """Run tests against the extracted problem block."""
+    __test__ = True
+
+
 @UseUnsafeCodejail()
-class TestPythonGradedResponse(TestSubmittingProblems):
+class BaseTestPythonGradedResponse(BaseTestSubmittingProblems):
     """
     Check that we can submit a schematic and custom response, and it answers properly.
     """
@@ -907,7 +988,10 @@ def strip_q(x):
     COMPUTED_ANSWER_CORRECT = "a shout in the street"
     COMPUTED_ANSWER_INCORRECT = "because we never let them in"
 
+    __test__ = False
+
     def setUp(self):
+        reset_class()
         super().setUp()
         self.section = self.add_graded_section_to_course('section')
         self.correct_responses = {}
@@ -1059,16 +1143,31 @@ def test_computed_reset(self):
         self._check_ireset(name)
 
 
-class TestConditionalContent(TestSubmittingProblems):
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=False)
+class TestPythonGradedResponseBuiltin(BaseTestPythonGradedResponse):
+    """Run tests against the built-in problem block."""
+    __test__ = True
+
+
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=True)
+class TestPythonGradedResponseExtracted(BaseTestPythonGradedResponse):
+    """Run tests against the extracted problem block."""
+    __test__ = True
+
+
+class BaseTestConditionalContent(BaseTestSubmittingProblems):
     """
     Check that conditional content works correctly with grading.
     """
+    __test__ = False
+
     def setUp(self):
         """
         Set up a simple course with a grading policy, a UserPartition, and 2 sections, both graded as "homework".
         One section is pre-populated with a problem (with 2 inputs), visible to all students.
         The second section is empty. Test cases should add conditional content to it.
         """
+        reset_class()
         super().setUp()
 
         self.user_partition_group_0 = 0
@@ -1265,3 +1364,15 @@ def test_split_one_group_no_problems_group_1(self):
         #   homework_2_score = 1.0 / 1
         #   round((homework_1_score + homework_2_score) / 2) == .75
         self.check_grade_percent(.75)
+
+
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=False)
+class TestConditionalContentBuiltin(BaseTestConditionalContent):
+    """Run tests against the built-in problem block."""
+    __test__ = True
+
+
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=True)
+class TestConditionalContentExtracted(BaseTestConditionalContent):
+    """Run tests against the extracted problem block."""
+    __test__ = True

lms/djangoapps/grades/tests/integration/test_problems.py

@@ -1,10 +1,12 @@
 # lint-amnesty, pylint: disable=missing-module-docstring
+from xmodule.capa_block import reset_class  # pylint: disable=wrong-import-order
 import datetime
 import itertools
 
 import ddt
 import pytz
 from crum import set_current_request
+from django.test.utils import override_settings
 from xmodule.graders import ProblemScore
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.tests.django_utils import (
@@ -25,10 +27,11 @@
 
 
 @ddt.ddt
-class TestMultipleProblemTypesSubsectionScores(SharedModuleStoreTestCase):
+class BaseTestMultipleProblemTypesSubsectionScores(SharedModuleStoreTestCase):
     """
     Test grading of different problem types.
     """
+    __test__ = False
     MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     SCORED_BLOCK_COUNT = 7
@@ -42,6 +45,7 @@ def setUpClass(cls):
         cls.seq1 = chapter1.get_children()[0]
 
     def setUp(self):
+        reset_class()
         super().setUp()
         self.student = UserFactory.create(is_staff=False, username='test_student', password=self.TEST_PASSWORD)
         self.client.login(username=self.student.username, password=self.TEST_PASSWORD)
@@ -98,12 +102,25 @@ def test_score_submission_for_all_problems(self):
         assert score.all_total.possible == (possible_per_block * block_count)
 
 
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=False)
+class TestMultipleProblemTypesSubsectionScoresBuiltin(BaseTestMultipleProblemTypesSubsectionScores):
+    """Run rescoring tests against the built-in problem block."""
+    __test__ = True
+
+
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=True)
+class TestMultipleProblemTypesSubsectionScoresExtracted(BaseTestMultipleProblemTypesSubsectionScores):
+    """Run rescoring tests against the extracted problem block."""
+    __test__ = True
+
+
 @ddt.ddt
-class TestVariedMetadata(ProblemSubmissionTestMixin, ModuleStoreTestCase):
+class BaseTestVariedMetadata(ProblemSubmissionTestMixin, ModuleStoreTestCase):
     """
     Test that changing the metadata on a block has the desired effect on the
     persisted score.
     """
+    __test__ = False
     MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     default_problem_metadata = {
@@ -113,6 +130,7 @@ class TestVariedMetadata(ProblemSubmissionTestMixin, ModuleStoreTestCase):
     }
 
     def setUp(self):
+        reset_class()
         super().setUp()
         self.course = CourseFactory.create()
         with self.store.bulk_operations(self.course.id):
@@ -209,11 +227,24 @@ def test_graded_metadata_alterations(self, alterations, expected_earned, expecte
         assert score.graded_total.possible == expected_possible
 
 
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=False)
+class TestVariedMetadataBuiltin(BaseTestVariedMetadata):
+    """Run rescoring tests against the built-in problem block."""
+    __test__ = True
+
+
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=True)
+class TestVariedMetadataExtracted(BaseTestVariedMetadata):
+    """Run rescoring tests against the extracted problem block."""
+    __test__ = True
+
+
 @ddt.ddt
-class TestWeightedProblems(SharedModuleStoreTestCase):
+class BaseTestWeightedProblems(SharedModuleStoreTestCase):
     """
     Test scores and grades with various problem weight values.
     """
+    __test__ = False
     MODULESTORE = TEST_DATA_SPLIT_MODULESTORE
 
     @classmethod
@@ -237,6 +268,7 @@ def setUpClass(cls):
                 )
 
     def setUp(self):
+        reset_class()
         super().setUp()
         self.user = UserFactory()
         self.addCleanup(set_current_request, None)
@@ -315,3 +347,15 @@ def test_problem_weight(self, raw_earned, raw_possible, weight):
             first_attempted=datetime.datetime(2010, 1, 1),
         )
         self._verify_grades(raw_earned, raw_possible, weight, expected_score)
+
+
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=False)
+class TestWeightedProblemsBuiltin(BaseTestWeightedProblems):
+    """Run rescoring tests against the built-in problem block."""
+    __test__ = True
+
+
+@override_settings(USE_EXTRACTED_PROBLEM_BLOCK=True)
+class TestWeightedProblemsExtracted(BaseTestWeightedProblems):
+    """Run rescoring tests against the extracted problem block."""
+    __test__ = True