feat: add new subsection visibility option to not show score but include grade in final calculation in progress page

Author: Anas12091101

src/course-home/data/api.js

@@ -3,25 +3,40 @@ import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
 import { logInfo } from '@edx/frontend-platform/logging';
 import { appendBrowserTimezoneToUrl } from '../../utils';
 
-const calculateAssignmentTypeGrades = (points, assignmentWeight, numDroppable) => {
+const calculateAssignmentTypeGrades = (points, visibilities, assignmentWeight, numDroppable) => {
   let dropCount = numDroppable;
   // Drop the lowest grades
   while (dropCount && points.length >= dropCount) {
     const lowestScore = Math.min(...points);
     const lowestScoreIndex = points.indexOf(lowestScore);
     points.splice(lowestScoreIndex, 1);
+    visibilities.splice(lowestScoreIndex, 1);
     dropCount--;
   }
   let averageGrade = 0;
   let weightedGrade = 0;
+  let totalWeightedGrade = 0;
+
   if (points.length) {
-    // Calculate the average grade for the assignment and round it. This rounding is not ideal and does not accurately
-    // reflect what a learner's grade would be, however, we must have parity with the current grading behavior that
-    // exists in edx-platform.
-    averageGrade = (points.reduce((a, b) => a + b, 0) / points.length).toFixed(4);
-    weightedGrade = averageGrade * assignmentWeight;
+    // Scores for visible grades (exclude never_but_include_grade)
+    const visibleScores = points.filter(
+      (_, idx) => visibilities[idx] !== 'never_but_include_grade',
+    );
+
+    // Average all scores (for totalWeightedGrade)
+    const overallAverage = parseFloat(
+      (points.reduce((a, b) => a + b, 0) / points.length).toFixed(4),
+    );
+    totalWeightedGrade = overallAverage * assignmentWeight;
+    if (visibleScores.length) {
+      const visibleAverage = parseFloat(
+        (visibleScores.reduce((a, b) => a + b, 0) / points.length).toFixed(4),
+      );
+      averageGrade = visibleAverage;
+      weightedGrade = averageGrade * assignmentWeight;
+    }
   }
-  return { averageGrade, weightedGrade };
+  return { averageGrade, weightedGrade, totalWeightedGrade };
 };
 
 function normalizeAssignmentPolicies(assignmentPolicies, sectionScores) {
@@ -33,6 +48,7 @@ function normalizeAssignmentPolicies(assignmentPolicies, sectionScores) {
       grades: Array(assignment.numTotal).fill(0),
       numAssignmentsCreated: 0,
       numTotalExpectedAssignments: assignment.numTotal,
+      visibility: Array(assignment.numTotal),
     };
   });
 
@@ -45,6 +61,7 @@ function normalizeAssignmentPolicies(assignmentPolicies, sectionScores) {
         assignmentType,
         numPointsEarned,
         numPointsPossible,
+        showCorrectness,
       } = subsection;
 
       // If a subsection's assignment type does not match an assignment policy in Studio,
@@ -64,17 +81,20 @@ function normalizeAssignmentPolicies(assignmentPolicies, sectionScores) {
         // Remove a placeholder grade so long as the number of recorded created assignments is less than the number
         // of expected assignments
         gradeByAssignmentType[assignmentType].grades.shift();
+        gradeByAssignmentType[assignmentType].visibility.shift();
       }
       // Add the graded assignment to the list
       gradeByAssignmentType[assignmentType].grades.push(numPointsEarned ? numPointsEarned / numPointsPossible : 0);
       // Record the created assignment
       gradeByAssignmentType[assignmentType].numAssignmentsCreated = numAssignmentsCreated;
+      gradeByAssignmentType[assignmentType].visibility.push(showCorrectness);
     });
   });
 
   return assignmentPolicies.map((assignment) => {
-    const { averageGrade, weightedGrade } = calculateAssignmentTypeGrades(
+    const { averageGrade, weightedGrade, totalWeightedGrade } = calculateAssignmentTypeGrades(
       gradeByAssignmentType[assignment.type].grades,
+      gradeByAssignmentType[assignment.type].visibility,
       assignment.weight,
       assignment.numDroppable,
     );
@@ -86,6 +106,7 @@ function normalizeAssignmentPolicies(assignmentPolicies, sectionScores) {
       type: assignment.type,
       weight: assignment.weight,
       weightedGrade,
+      totalWeightedGrade,
     };
   });
 }

src/course-home/progress-tab/ProgressTab.test.jsx

@@ -697,6 +697,187 @@ describe('Progress Tab', () => {
       // The row is comprised of "{Assignment type} {footnote - optional} {weight} {grade} {weighted grade}"
       expect(screen.getByRole('row', { name: 'Homework 1 100% 0% 0%' })).toBeInTheDocument();
     });
+
+    it('shows lock icon when all subsections of assignment type are never_but_include_grade', async () => {
+      setTabData({
+        grading_policy: {
+          assignment_policies: [
+            {
+              num_droppable: 0,
+              num_total: 2,
+              short_label: 'HW',
+              type: 'Homework',
+              weight: 1,
+            },
+          ],
+          grade_range: {
+            pass: 0.75,
+          },
+        },
+        section_scores: [
+          {
+            display_name: 'Section 1',
+            subsections: [
+              {
+                assignment_type: 'Homework',
+                display_name: 'Subsection 1',
+                learner_has_access: true,
+                has_graded_assignment: true,
+                num_points_earned: 1,
+                num_points_possible: 2,
+                percent_graded: 1.0,
+                show_correctness: 'never_but_include_grade',
+                show_grades: true,
+                url: 'http://learning.edx.org/course/course-v1:edX+Test+run/subsection1',
+              },
+              {
+                assignment_type: 'Homework',
+                display_name: 'Subsection 2',
+                learner_has_access: true,
+                has_graded_assignment: true,
+                num_points_earned: 1,
+                num_points_possible: 2,
+                percent_graded: 1.0,
+                show_correctness: 'never_but_include_grade',
+                show_grades: true,
+                url: 'http://learning.edx.org/course/course-v1:edX+Test+run/subsection2',
+              },
+            ],
+          },
+        ],
+      });
+      await fetchAndRender();
+      // Should show lock icon for grade and weighted grade
+      expect(screen.getAllByTestId('lock-icon')).toHaveLength(2);
+    });
+
+    it.only('shows percent plus hidden grades when some subsections of assignment type are never_but_include_grade', async () => {
+      setTabData({
+        grading_policy: {
+          assignment_policies: [
+            {
+              num_droppable: 0,
+              num_total: 2,
+              short_label: 'HW',
+              type: 'Homework',
+              weight: 1,
+            },
+          ],
+          grade_range: {
+            pass: 0.75,
+          },
+        },
+        section_scores: [
+          {
+            display_name: 'Section 1',
+            subsections: [
+              {
+                assignment_type: 'Homework',
+                display_name: 'Subsection 1',
+                learner_has_access: true,
+                has_graded_assignment: true,
+                num_points_earned: 1,
+                num_points_possible: 2,
+                percent_graded: 1.0,
+                show_correctness: 'never_but_include_grade',
+                show_grades: true,
+                url: 'http://learning.edx.org/course/course-v1:edX+Test+run/subsection1',
+              },
+              {
+                assignment_type: 'Homework',
+                display_name: 'Subsection 2',
+                learner_has_access: true,
+                has_graded_assignment: true,
+                num_points_earned: 1,
+                num_points_possible: 2,
+                percent_graded: 1.0,
+                show_correctness: 'always',
+                show_grades: true,
+                url: 'http://learning.edx.org/course/course-v1:edX+Test+run/subsection2',
+              },
+            ],
+          },
+        ],
+      });
+      await fetchAndRender();
+      // Should show percent + hidden scores for grade and weighted grade
+      const hiddenScoresCells = screen.getAllByText(/% \+ Hidden Scores/);
+      expect(hiddenScoresCells).toHaveLength(2);
+      // Only correct visible scores should be shown (from subsection2)
+      // The correct visible score is 1/4 = 0.25 -> 25%
+      expect(hiddenScoresCells[0]).toHaveTextContent('25% + Hidden Scores');
+      expect(hiddenScoresCells[1]).toHaveTextContent('25% + Hidden Scores');
+    });
+
+    it('displays a warning message with the latest due date when not all assignment scores are included in the total grade', async () => {
+      setTabData({
+        grading_policy: {
+          assignment_policies: [
+            {
+              num_droppable: 0,
+              num_total: 2,
+              short_label: 'HW',
+              type: 'Homework',
+              weight: 1,
+            },
+          ],
+          grade_range: {
+            pass: 0.75,
+          },
+        },
+        section_scores: [
+          {
+            display_name: 'Section 1',
+            subsections: [
+              {
+                assignment_type: 'Homework',
+                display_name: 'Subsection 1',
+                due: tomorrow.toISOString(),
+                learner_has_access: true,
+                has_graded_assignment: true,
+                num_points_earned: 1,
+                num_points_possible: 2,
+                percent_graded: 1.0,
+                show_correctness: 'never_but_include_grade',
+                show_grades: true,
+                url: 'http://learning.edx.org/course/course-v1:edX+Test+run/subsection1',
+              },
+              {
+                assignment_type: 'Homework',
+                display_name: 'Subsection 2',
+                due: null,
+                learner_has_access: true,
+                has_graded_assignment: true,
+                num_points_earned: 1,
+                num_points_possible: 2,
+                percent_graded: 1.0,
+                show_correctness: 'always',
+                show_grades: true,
+                url: 'http://learning.edx.org/course/course-v1:edX+Test+run/subsection2',
+              },
+            ],
+          },
+        ],
+      });
+
+      await fetchAndRender();
+
+      const formattedDateTime = new Intl.DateTimeFormat('en', {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: 'numeric',
+        timeZoneName: 'short',
+      }).format(tomorrow);
+
+      expect(
+        screen.getByText(
+          `Some assignment scores are not yet included in your total grade. These grades will be released by ${formattedDateTime}.`,
+        ),
+      ).toBeInTheDocument();
+    });
+
     it('calculates grades correctly when number of droppable assignments is less than total number of assignments', async () => {
       await fetchAndRender();
       expect(screen.getByText('Grade summary')).toBeInTheDocument();