From ed2910b0eaa1cbca5f29fb5d85fb75369536c304 Mon Sep 17 00:00:00 2001
From: Yanzhen Chen <yanzhenchen123@gmail.com>
Date: Thu, 18 Jun 2026 18:29:29 -0400
Subject: [PATCH 1/2] Add grades tab upload flow

---
 app/controllers/assignments_controller.rb     |  13 ++
 .../Modals/assignment_grades_upload_modal.jsx |  69 ++++++++++
 .../Components/assignment_summary.jsx         |   2 +
 .../Components/assignment_summary_table.jsx   |  17 +++
 app/models/assignment.rb                      | 120 +++++++++++++++++
 app/policies/assignment_policy.rb             |   1 +
 app/views/assignments/summary.html.erb        |   3 +-
 config/locales/views/assignments/en.yml       |   3 +
 config/routes.rb                              |   1 +
 .../assignments_controller_spec.rb            |  47 +++++++
 spec/models/assignment_spec.rb                | 127 ++++++++++++++++++
 11 files changed, 402 insertions(+), 1 deletion(-)
 create mode 100644 app/javascript/Components/Modals/assignment_grades_upload_modal.jsx

diff --git a/app/controllers/assignments_controller.rb b/app/controllers/assignments_controller.rb
index 9029566850..4297311054 100644
--- a/app/controllers/assignments_controller.rb
+++ b/app/controllers/assignments_controller.rb
@@ -268,6 +268,19 @@ def summary
     end
   end
 
+  def upload_grades
+    @assignment = record
+    begin
+      data = process_file_upload(['.csv'])
+    rescue StandardError => e
+      flash_message(:error, e.message)
+    else
+      result = @assignment.import_marks_from_csv(data[:contents], params[:overwrite], current_role)
+      flash_csv_result(result)
+    end
+    redirect_to action: 'summary', id: @assignment.id
+  end
+
   def download_test_results
     @assignment = record
     respond_to do |format|
diff --git a/app/javascript/Components/Modals/assignment_grades_upload_modal.jsx b/app/javascript/Components/Modals/assignment_grades_upload_modal.jsx
new file mode 100644
index 0000000000..1fbfa01d1c
--- /dev/null
+++ b/app/javascript/Components/Modals/assignment_grades_upload_modal.jsx
@@ -0,0 +1,69 @@
+import React from "react";
+import Modal from "react-modal";
+
+class AssignmentGradesUploadModal extends React.Component {
+  componentDidMount() {
+    Modal.setAppElement("body");
+  }
+
+  authenticityToken() {
+    return document.querySelector("meta[name='csrf-token']")?.content || "";
+  }
+
+  render() {
+    return (
+      <Modal
+        className="react-modal markus-dialog"
+        isOpen={this.props.isOpen}
+        onRequestClose={this.props.onRequestClose}
+      >
+        <h2>
+          {I18n.t("upload_the", {
+            item: I18n.t("assignments.grades"),
+          })}
+        </h2>
+        <form
+          action={Routes.upload_grades_course_assignment_path(
+            this.props.course_id,
+            this.props.assignment_id
+          )}
+          encType="multipart/form-data"
+          method="post"
+        >
+          <div className="modal-container-vertical">
+            <input type="hidden" name="authenticity_token" value={this.authenticityToken()} />
+            <p>
+              <input type="file" name="upload_file" required={true} accept=".csv" />
+            </p>
+            <p>
+              <label htmlFor="encoding">{I18n.t("encoding")}</label>
+              <select id="encoding" name="encoding" defaultValue="UTF-8">
+                {this.props.encodings.map(([label, value]) => (
+                  <option key={value} value={value}>
+                    {label}
+                  </option>
+                ))}
+              </select>
+            </p>
+            <p>
+              <label htmlFor="overwrite">
+                <input type="checkbox" id="overwrite" name="overwrite" />{" "}
+                {I18n.t("assignments.upload_grades.overwrite")}
+              </label>
+            </p>
+            <section className="dialog-actions">
+              <input
+                type="submit"
+                value={I18n.t("upload")}
+                data-disable-with={I18n.t("uploading_please_wait")}
+              />
+              <input onClick={this.props.onRequestClose} type="reset" value={I18n.t("cancel")} />
+            </section>
+          </div>
+        </form>
+      </Modal>
+    );
+  }
+}
+
+export default AssignmentGradesUploadModal;
diff --git a/app/javascript/Components/assignment_summary.jsx b/app/javascript/Components/assignment_summary.jsx
index 827299c204..9a5b6abc1e 100644
--- a/app/javascript/Components/assignment_summary.jsx
+++ b/app/javascript/Components/assignment_summary.jsx
@@ -18,6 +18,7 @@ class AssignmentSummary extends React.Component {
               course_id={this.props.course_id}
               assignment_id={this.props.assessment_id}
               is_instructor={this.props.is_instructor}
+              encodings={this.props.encodings}
               lti_deployments={this.props.lti_deployments}
             />
           </TabPanel>
@@ -38,6 +39,7 @@ class AssignmentSummary extends React.Component {
           course_id={this.props.course_id}
           assignment_id={this.props.assessment_id}
           is_instructor={this.props.is_instructor}
+          encodings={this.props.encodings}
           lti_deployments={this.props.lti_deployments}
         />
       );
diff --git a/app/javascript/Components/assignment_summary_table.jsx b/app/javascript/Components/assignment_summary_table.jsx
index 28c5f4de21..fa165492e4 100644
--- a/app/javascript/Components/assignment_summary_table.jsx
+++ b/app/javascript/Components/assignment_summary_table.jsx
@@ -1,6 +1,7 @@
 import React from "react";
 import {getMarkingStates, selectFilter} from "./Helpers/table_helpers";
 
+import AssignmentGradesUploadModal from "./Modals/assignment_grades_upload_modal";
 import DownloadTestResultsModal from "./Modals/download_test_results_modal";
 import LtiGradeModal from "./Modals/send_lti_grades_modal";
 import {createColumnHelper} from "@tanstack/react-table";
@@ -20,6 +21,7 @@ export class AssignmentSummaryTable extends React.Component {
       marking_states: markingStates,
       markingStateFilter: "all",
       showDownloadTestsModal: false,
+      showGradesUploadModal: false,
       showLtiGradeModal: false,
       lti_deployments: [],
       columnFilters: [{id: "inactive", value: false}],
@@ -361,6 +363,10 @@ export class AssignmentSummaryTable extends React.Component {
     this.setState({showDownloadTestsModal: true});
   };
 
+  onGradesUploadModal = () => {
+    this.setState({showGradesUploadModal: true});
+  };
+
   onLtiGradeModal = () => {
     this.setState({showLtiGradeModal: true});
   };
@@ -433,6 +439,10 @@ export class AssignmentSummaryTable extends React.Component {
                   {I18n.t("download")}
                 </button>
               </form>
+              <button type="button" name="upload" onClick={this.onGradesUploadModal}>
+                <i className="fa-solid fa-upload" aria-hidden="true" />
+                {I18n.t("upload")}
+              </button>
               {this.state.enable_test && (
                 <button type="submit" name="download_tests" onClick={this.onDownloadTestsModal}>
                   {I18n.t("download_the", {
@@ -462,6 +472,13 @@ export class AssignmentSummaryTable extends React.Component {
           }}
           loading={this.state.loading}
         />
+        <AssignmentGradesUploadModal
+          course_id={this.props.course_id}
+          assignment_id={this.props.assignment_id}
+          encodings={this.props.encodings || []}
+          isOpen={this.state.showGradesUploadModal}
+          onRequestClose={() => this.setState({showGradesUploadModal: false})}
+        />
         <DownloadTestResultsModal
           course_id={this.props.course_id}
           assignment_id={this.props.assignment_id}
diff --git a/app/models/assignment.rb b/app/models/assignment.rb
index b440f83642..49a1eb05cb 100644
--- a/app/models/assignment.rb
+++ b/app/models/assignment.rb
@@ -866,6 +866,64 @@ def summary_csv(role)
     end
   end
 
+  def import_marks_from_csv(grades_data, overwrite, role)
+    results_by_group_name = current_results
+                            .joins(grouping: :group)
+                            .includes(:marks, grouping: :group)
+                            .index_by { |result| result.grouping.group.group_name }
+    results_by_user_name = current_results
+                           .joins(grouping: { accepted_students: :user })
+                           .includes(:marks)
+                           .pluck('users.user_name', 'results.id')
+                           .to_h
+    results_by_id = results_by_group_name.values.index_by(&:id)
+    criteria_by_name = criteria_by_upload_name
+
+    headers = nil
+    criterion_columns = nil
+    group_name_index = nil
+    user_name_index = nil
+
+    MarkusCsv.parse(grades_data, header_count: 2) do |row|
+      next if row.empty?
+
+      if headers.nil?
+        headers = row
+        group_name_index = headers.index(Group.human_attribute_name(:group_name)) || 0
+        user_name_index = headers.index(User.human_attribute_name(:user_name)) || 1
+        next
+      elsif criterion_columns.nil?
+        begin
+          criterion_columns = assignment_upload_criterion_columns(headers, row, criteria_by_name)
+        rescue CsvInvalidLineError
+          criterion_columns = :invalid
+          raise
+        end
+        next
+      end
+
+      raise CsvInvalidLineError if criterion_columns == :invalid
+
+      result = result_for_uploaded_marks_row(row, group_name_index, user_name_index,
+                                             results_by_group_name, results_by_user_name, results_by_id)
+      raise CsvInvalidLineError if result.nil? || result.released_to_students?
+
+      Mark.transaction do
+        criterion_columns.each do |column_index, criterion|
+          mark = result.marks.find_or_initialize_by(criterion: criterion)
+          next if !overwrite && !mark.mark.nil?
+
+          mark_value = parse_uploaded_mark(row[column_index])
+          unless mark.update(mark: mark_value,
+                             override: !(mark_value.nil? && mark.deductive_annotations_absent?),
+                             last_updated_by: role)
+            raise CsvInvalidLineError, mark.errors.full_messages.to_sentence
+          end
+        end
+      end
+    end
+  end
+
   # Returns an array of [mark, max_mark].
   def get_marks_list(submission)
     criteria.map do |criterion|
@@ -881,6 +939,68 @@ def next_criterion_position
     criteria.exists? ? criteria.last.position + 1 : 1
   end
 
+  def criteria_by_upload_name
+    ta_criteria.each_with_object({}) do |criterion, mapping|
+      mapping[criterion.name.to_s.strip] = criterion
+      if criterion.bonus?
+        mapping["#{criterion.name} (#{Criterion.human_attribute_name(:bonus)})".strip] = criterion
+      end
+    end
+  end
+
+  def assignment_upload_criterion_columns(headers, totals, criteria_by_name)
+    unknown_columns = []
+    columns = headers.each_with_index.filter_map do |header, i|
+      header = header.to_s.strip
+      criterion = criteria_by_name[header]
+      next [i, criterion] unless criterion.nil?
+
+      if uploaded_assignment_mark_column?(header, totals[i])
+        unknown_columns << header
+      end
+      nil
+    end
+
+    if columns.empty? || unknown_columns.present?
+      raise CsvInvalidLineError,
+            I18n.t('assignments.upload_grades.invalid_criteria', criteria: unknown_columns.join(', '))
+    end
+
+    columns
+  end
+
+  def uploaded_assignment_mark_column?(header, total)
+    return false if header.blank?
+    return false if header == I18n.t('results.total_mark') || header == 'Bonus/Deductions'
+
+    total_value = Float(total, exception: false)
+    !total_value.nil? && total_value >= 0
+  end
+
+  def result_for_uploaded_marks_row(row, group_name_index, user_name_index,
+                                    results_by_group_name, results_by_user_name, results_by_id)
+    group_name = row[group_name_index]
+    user_name = row[user_name_index]
+    return results_by_group_name[group_name] if group_name.present? && results_by_group_name.key?(group_name)
+
+    result_id = results_by_user_name[user_name]
+    results_by_id[result_id]
+  end
+
+  def parse_uploaded_mark(value)
+    return if value.blank?
+
+    mark = Float(value, exception: false)
+    raise CsvInvalidLineError if mark.nil? || mark.negative?
+
+    mark
+  end
+  private :criteria_by_upload_name,
+          :assignment_upload_criterion_columns,
+          :uploaded_assignment_mark_column?,
+          :result_for_uploaded_marks_row,
+          :parse_uploaded_mark
+
   # Returns all the submissions that have not been graded (completed).
   # Note: This assumes that every submission has at least one result.
   def ungraded_submission_results
diff --git a/app/policies/assignment_policy.rb b/app/policies/assignment_policy.rb
index 3a7d92989d..592c6a9df8 100644
--- a/app/policies/assignment_policy.rb
+++ b/app/policies/assignment_policy.rb
@@ -2,6 +2,7 @@
 class AssignmentPolicy < ApplicationPolicy
   default_rule :manage?
   alias_rule :summary?, to: :view?
+  alias_rule :upload_grades?, to: :manage?
   alias_rule :stop_batch_tests?, :batch_runs?, to: :manage_tests?
   alias_rule :show?, :peer_review?, to: :student?
   alias_rule :starter_file?, :download_starter_file_mappings?, :download_sample_starter_files?,
diff --git a/app/views/assignments/summary.html.erb b/app/views/assignments/summary.html.erb
index 7aa024e87a..c3494406a5 100644
--- a/app/views/assignments/summary.html.erb
+++ b/app/views/assignments/summary.html.erb
@@ -7,7 +7,8 @@
         {
           course_id: <%= @current_course.id %>,
           assessment_id: <%= @assignment.id %>,
-          is_instructor: <%= @current_role.instructor? %>
+          is_instructor: <%= @current_role.instructor? %>,
+          encodings: <%= raw @encodings.to_json %>
         }
       );
     });
diff --git a/config/locales/views/assignments/en.yml b/config/locales/views/assignments/en.yml
index 7892b572c7..1a08207b4a 100644
--- a/config/locales/views/assignments/en.yml
+++ b/config/locales/views/assignments/en.yml
@@ -109,3 +109,6 @@ en:
     upload_config_help_html: "<p>This zip file will configure and create this assignment.</p><p>This does not configure student or grader settings.<br>For more information please visit <a href=https://github.com/MarkUsProject/Wiki/blob/%{markus_version}/Instructor-Guide--Importing-and-Exporting-Data.md#%{section_id}>this page</a>.</p>"
     upload_file_requirement: Filename %{file_name} is not allowed for this assignment.
     upload_file_requirement_in_folder: Filename %{file_name} in %{file_path} is not allowed for this assignment.
+    upload_grades:
+      invalid_criteria: 'No matching criteria were found in the uploaded CSV. Unknown criteria: %{criteria}'
+      overwrite: Overwrite existing grades?
diff --git a/config/routes.rb b/config/routes.rb
index 2f922e2f43..69ca2e7fcd 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -789,6 +789,7 @@
         get 'peer_review'
         get 'populate_starter_file_manager'
         get 'summary'
+        post 'upload_grades'
         get 'batch_runs'
         post 'set_boolean_graders_options'
         get 'stop_test'
diff --git a/spec/controllers/assignments_controller_spec.rb b/spec/controllers/assignments_controller_spec.rb
index 090b2c57fd..dce6f60660 100644
--- a/spec/controllers/assignments_controller_spec.rb
+++ b/spec/controllers/assignments_controller_spec.rb
@@ -152,6 +152,49 @@
     end
   end
 
+  describe '#upload_grades' do
+    let(:course) { create(:course) }
+    let(:role) { create(:instructor, course: course) }
+    let(:assignment) { create(:assignment, course: course) }
+    let!(:criterion) do
+      create(:flexible_criterion, assignment: assignment, name: 'Correctness', max_mark: 10, position: 1)
+    end
+    let!(:grouping) { create(:grouping_with_inviter_and_submission, assignment: assignment) }
+    let(:student) { grouping.inviter }
+    let(:csv_data) do
+      headers = [Group.human_attribute_name(:group_name)] +
+        Student::CSV_ORDER.map { |field| User.human_attribute_name(field) } +
+        [I18n.t('results.total_mark'), criterion.name, 'Bonus/Deductions']
+      totals = [' '] * Student::CSV_ORDER.length +
+        [Assessment.human_attribute_name(:max_mark), assignment.max_mark, criterion.max_mark, '']
+      row = [grouping.group.group_name] +
+        Student::CSV_ORDER.map { |field| student.public_send(field) } +
+        [999, 8, 100]
+      MarkusCsv.generate([headers, totals, row], &:itself)
+    end
+    let(:upload_file) do
+      file = Tempfile.new(['assignment_grades', '.csv'])
+      file.write(csv_data)
+      file.rewind
+      @upload_files << file
+      Rack::Test::UploadedFile.new(file.path, 'text/csv')
+    end
+
+    before { @upload_files = [] }
+
+    after { @upload_files.each(&:close!) }
+
+    it 'uploads criterion marks and redirects back to the assignment grades tab' do
+      post_as role, :upload_grades,
+              params: { course_id: course.id, id: assignment.id, upload_file: upload_file, overwrite: true }
+
+      expect(response).to have_http_status(:found)
+      expect(response).to redirect_to(summary_course_assignment_path(course, assignment))
+      expect(flash[:error]).to be_nil
+      expect(grouping.current_result.reload.mark_hash[criterion.id][:mark]).to eq 8
+    end
+  end
+
   context 'download the most recent test results as CSV' do
     let(:user) { create(:instructor) }
     let(:assignment) { create(:assignment_with_criteria_and_test_results) }
@@ -692,6 +735,7 @@
       example_form_params[:assignment][:submission_rule_attributes][:periods_attributes] = submission_rule.id
       example_form_params
     end
+
     it 'should update an assignment without errors' do
       expect { patch_as role, :update, params: params }.not_to raise_error
     end
@@ -958,6 +1002,7 @@
     let(:assignment) { create(:assignment_for_tests) }
     let(:grouping) { create(:grouping, assignment: assignment) }
     let(:test_run) { create(:test_run, grouping: grouping) }
+
     describe '#batch_runs' do
       before { get_as role, :batch_runs, params: { course_id: course.id, id: assignment.id } }
 
@@ -1403,6 +1448,7 @@
       let!(:starter_file_group) { create(:starter_file_group_with_entries, assignment: assignment) }
       let!(:grouping) { create(:grouping_with_inviter, assignment: assignment) }
       let(:params) { { course_id: assignment.course.id, id: starter_file_group.assignment.id } }
+
       it 'should return a 200 status code' do
         subject
         expect(response).to have_http_status(:ok)
@@ -1726,6 +1772,7 @@
 
     shared_examples 'download sample starter files' do
       let(:structure) { { 'q1/': nil, 'q1/q1.txt': 'q1 content', 'q2.txt': 'q2 content' } }
+
       # NOTE: other starter_file_type are not tested because they involve randomness and so are not deterministic
       before { create(:starter_file_group_with_entries, assignment: assignment, structure: structure) }
 
diff --git a/spec/models/assignment_spec.rb b/spec/models/assignment_spec.rb
index abaa5c6e1b..43240cb58a 100644
--- a/spec/models/assignment_spec.rb
+++ b/spec/models/assignment_spec.rb
@@ -2470,6 +2470,133 @@ def grouping_count(groupings)
     end
   end
 
+  describe '#import_marks_from_csv' do
+    let(:course) { create(:course) }
+    let(:instructor) { create(:instructor, course: course) }
+    let(:assignment) { create(:assignment, course: course) }
+    let!(:criterion1) do
+      create(:flexible_criterion, assignment: assignment, name: 'Correctness', max_mark: 10, position: 1)
+    end
+    let!(:criterion2) do
+      create(:flexible_criterion, assignment: assignment, name: 'Style', max_mark: 5, position: 2)
+    end
+    let!(:bonus_criterion) do
+      create(:flexible_criterion, assignment: assignment, name: 'Bonus', max_mark: 2, position: 3, bonus: true)
+    end
+    let!(:grouping1) { create(:grouping_with_inviter_and_submission, assignment: assignment) }
+    let!(:grouping2) { create(:grouping_with_inviter_and_submission, assignment: assignment) }
+
+    def assignment_grades_csv(assignment, rows, headers: nil, totals: nil)
+      headers ||= [Group.human_attribute_name(:group_name)] +
+        Student::CSV_ORDER.map { |field| User.human_attribute_name(field) } +
+        [I18n.t('results.total_mark'),
+         'Correctness',
+         'Style',
+         "Bonus (#{Criterion.human_attribute_name(:bonus)})",
+         'Bonus/Deductions']
+      totals ||= [' '] * Student::CSV_ORDER.length +
+        [Assessment.human_attribute_name(:max_mark), assignment.max_mark, 10, 5, 2, '']
+      MarkusCsv.generate([headers, totals] + rows, &:itself)
+    end
+
+    def assignment_grades_row(grouping, correctness, style, bonus, total: 999, extra_marks: 100)
+      student = grouping.inviter
+      [grouping.group.group_name] +
+        Student::CSV_ORDER.map { |field| student.public_send(field) } +
+        [total, correctness, style, bonus, extra_marks]
+    end
+
+    it 'uploads criterion marks while ignoring total and extra marks columns' do
+      csv_data = assignment_grades_csv(
+        assignment,
+        [assignment_grades_row(grouping1, 8, 4, 1.5)]
+      )
+
+      result = assignment.import_marks_from_csv(csv_data, true, instructor)
+
+      expect(result[:invalid_lines]).to be_empty
+      marks = grouping1.current_result.reload.mark_hash
+      expect(marks[criterion1.id][:mark]).to eq 8
+      expect(marks[criterion2.id][:mark]).to eq 4
+      expect(marks[bonus_criterion.id][:mark]).to eq 1.5
+      expect(grouping1.current_result.extra_marks).to be_empty
+    end
+
+    it 'does not overwrite existing marks unless overwrite is selected' do
+      grouping1.current_result.marks.find_by(criterion: criterion1).update!(mark: 7)
+      csv_data = assignment_grades_csv(
+        assignment,
+        [assignment_grades_row(grouping1, 3, 4, 1)]
+      )
+
+      assignment.import_marks_from_csv(csv_data, false, instructor)
+
+      marks = grouping1.current_result.reload.mark_hash
+      expect(marks[criterion1.id][:mark]).to eq 7
+      expect(marks[criterion2.id][:mark]).to eq 4
+    end
+
+    it 'overwrites existing marks when overwrite is selected' do
+      grouping1.current_result.marks.find_by(criterion: criterion1).update!(mark: 7)
+      csv_data = assignment_grades_csv(
+        assignment,
+        [assignment_grades_row(grouping1, 3, 4, 1)]
+      )
+
+      assignment.import_marks_from_csv(csv_data, true, instructor)
+
+      expect(grouping1.current_result.reload.mark_hash[criterion1.id][:mark]).to eq 3
+    end
+
+    it 'reports invalid rows while still processing valid rows' do
+      invalid_row = assignment_grades_row(grouping1, 6, 2, 1)
+      invalid_row[0] = 'unknown_group'
+      invalid_row[1 + Student::CSV_ORDER.index(:user_name)] = 'unknown_user'
+      csv_data = assignment_grades_csv(
+        assignment,
+        [invalid_row, assignment_grades_row(grouping2, 9, 5, 2)]
+      )
+
+      result = assignment.import_marks_from_csv(csv_data, true, instructor)
+
+      expect(result[:invalid_lines]).to include('unknown_group')
+      expect(grouping1.current_result.reload.mark_hash[criterion1.id][:mark]).to be_nil
+      expect(grouping2.current_result.reload.mark_hash[criterion1.id][:mark]).to eq 9
+    end
+
+    it 'does not update released results' do
+      grouping1.current_result.update!(released_to_students: true)
+      csv_data = assignment_grades_csv(
+        assignment,
+        [assignment_grades_row(grouping1, 8, 4, 1)]
+      )
+
+      result = assignment.import_marks_from_csv(csv_data, true, instructor)
+
+      expect(result[:invalid_lines]).to include(grouping1.group.group_name)
+      expect(grouping1.current_result.reload.mark_hash[criterion1.id][:mark]).to be_nil
+    end
+
+    it 'rejects unknown criterion columns' do
+      headers = [Group.human_attribute_name(:group_name)] +
+        Student::CSV_ORDER.map { |field| User.human_attribute_name(field) } +
+        [I18n.t('results.total_mark'), 'Unknown criterion', 'Bonus/Deductions']
+      totals = [' '] * Student::CSV_ORDER.length +
+        [Assessment.human_attribute_name(:max_mark), assignment.max_mark, 1, '']
+      csv_data = assignment_grades_csv(
+        assignment,
+        [assignment_grades_row(grouping1, 8, 4, 1)],
+        headers: headers,
+        totals: totals
+      )
+
+      result = assignment.import_marks_from_csv(csv_data, true, instructor)
+
+      expect(result[:invalid_lines]).to include('Unknown criterion')
+      expect(grouping1.current_result.reload.mark_hash[criterion1.id][:mark]).to be_nil
+    end
+  end
+
   describe '#upcoming' do
     # the upcoming method is only called in cases where the user is a student
     context 'a student with a grouping' do

From 815571fa1ce4147e3d0630b127e8883dfe3448c3 Mon Sep 17 00:00:00 2001
From: Yanzhen Chen <yanzhenchen123@gmail.com>
Date: Thu, 18 Jun 2026 18:33:53 -0400
Subject: [PATCH 2/2] changelog

---
 Changelog.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Changelog.md b/Changelog.md
index 40fe728b02..72571defd7 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -7,6 +7,7 @@
 ### 🚨 Breaking changes
 
 ### ✨ New features and improvements
+- Added CSV upload support for criterion marks in the assignment Grades tab (#8008)
 - Added a confirm dialog to the Upload Scans form that appears when no template divisions are assigned to the selected exam template (#7993)
 - Migrated `MarkingSchemesTable` component to React Table V8 (#7985)
 - Removed Graders Subcomponent and added a Graders column in the Assignment Grades tab (#7967)