chore(marketplace): reap aged preview submissions on a TTL

Weekly, keyed on last activity rather than creation so an in-progress
rehearsal is never reaped out from under someone. Never touches the container
course, the assessment copies or the previewers' enrolments — those are
deliberately reused across preview sessions.

The cron sets only how long past the TTL a submission may linger, not how long
it is kept: starting over is the banner's Reset submission button, not this.

Author: LWS49

app/jobs/course/assessment/marketplace/preview_submission_reaping_job.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+# Reaps aged marketplace preview submissions on a TTL, scheduled weekly via `config/schedule.yml`
+# (`Course::Assessment::Marketplace::PreviewContainerService`'s container course is the only source of
+# these submissions). Never touches the container course, the assessment copies, or the previewers'
+# enrolments — those are deliberately persistent and reused across preview sessions.
+class Course::Assessment::Marketplace::PreviewSubmissionReapingJob < ApplicationJob
+  # Keyed on `updated_at` (last activity), not `created_at`, so an in-progress rehearsal is never
+  # reaped out from under someone still working, and async autograding has time to land before a
+  # destroy could race it.
+  #
+  # This is the floor on how long an attempt is kept, not the ceiling: the weekly cron means an aged
+  # submission may linger up to a week past it.
+  PREVIEW_SUBMISSION_TTL = 24.hours
+
+  # Cap deletions per run to avoid bricking the worker (mirrors UserEmailDatabaseCleanupJob). Note
+  # this caps a WEEK's reaping, not an hour's: if preview volume ever exceeds it, aged submissions
+  # accumulate faster than they are removed and the cron needs raising before this does.
+  REAP_BATCH_SIZE = 1000
+
+  def perform
+    ActsAsTenant.without_tenant do
+      reap_aged_preview_submissions
+    end
+  end
+
+  private
+
+  def reap_aged_preview_submissions
+    User.with_stamper(User.system) do
+      Course::Assessment::Submission.transaction do
+        aged_preview_submissions.group_by(&:assessment).each do |assessment, submissions|
+          creator_ids = []
+          submissions.each do |submission|
+            submission.destroy!
+            creator_ids << submission.creator_id
+          end
+
+          Course::Assessment::Submission::MonitoringService.destroy_all_by(assessment, creator_ids)
+        end
+      end
+    end
+  end
+
+  # Derived from the course, not a deep join: `Course::Assessment` is `acts_as` a
+  # `Course::LessonPlan::Item`, so a `joins(assessment: { tab: :category })` chain is fragile.
+  def aged_preview_submissions
+    preview_assessment_ids = Course.where(preview: true).flat_map { |course| course.assessments.pluck(:id) }
+
+    Course::Assessment::Submission.
+      includes(:assessment).
+      where(assessment_id: preview_assessment_ids).
+      where(updated_at: ...PREVIEW_SUBMISSION_TTL.ago).
+      limit(REAP_BATCH_SIZE)
+  end
+end

config/schedule.yml

@@ -15,3 +15,12 @@ user_email_database_cleanup_job:
   cron: '0 0 1 * *'
   class: 'UserEmailDatabaseCleanupJob'
   queue: 'default'
+
+# Reap aged marketplace preview submissions every Sunday at 21:20 UTC, 5:20 AM SGT Monday. The TTL
+# is enforced in the job, not the cron, so this interval sets only how long past the TTL a submission
+# may linger — not how long it is kept. Previewers do not wait on it to start over; the preview
+# banner's "Reset submission" button clears an attempt on demand.
+preview_submission_reaping_job:
+  cron: '20 21 * * 0'
+  class: 'Course::Assessment::Marketplace::PreviewSubmissionReapingJob'
+  queue: 'default'

spec/jobs/course/assessment/marketplace/preview_submission_reaping_job_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+require 'rails_helper'
+
+RSpec.describe Course::Assessment::Marketplace::PreviewSubmissionReapingJob, type: :job do
+  # Own instance: at most one `preview: true` course may exist per instance, and the job runs
+  # `without_tenant`, so it reaps this course's submissions wherever the course lives.
+  let(:instance) { create(:instance) }
+
+  with_tenant(:instance) do
+    let(:ttl) { described_class::PREVIEW_SUBMISSION_TTL }
+
+    subject { described_class.perform_now }
+
+    # `update_column` bypasses `updated_at`'s own touch, unlike `update!`/`touch`.
+    def age!(submission, ago:)
+      submission.update_column(:updated_at, ago)
+    end
+
+    context 'a preview submission older than the TTL' do
+      let!(:preview_course) { create(:course, preview: true) }
+      let!(:preview_assessment) { create(:assessment, :with_mcq_question, course: preview_course) }
+      let!(:previewer) { create(:user) }
+      let!(:aged_submission) do
+        submission = create(:submission, :attempting, assessment: preview_assessment,
+                                                      course: preview_course, creator: previewer)
+        age!(submission, ago: (ttl + 1.hour).ago)
+        submission
+      end
+
+      it 'reaps the aged preview submission' do
+        expect { subject }.
+          to change { Course::Assessment::Submission.exists?(aged_submission.id) }.from(true).to(false)
+      end
+
+      it 'cascades: the reaped submission\'s answers are destroyed too' do
+        expect { subject }.
+          to change { Course::Assessment::Answer.where(submission_id: aged_submission.id).exists? }.
+          from(true).to(false)
+      end
+
+      it 'leaves the preview course, the assessment, and the enrolment alone' do
+        subject
+
+        expect(Course.exists?(preview_course.id)).to be(true)
+        expect(Course::Assessment.exists?(preview_assessment.id)).to be(true)
+        expect(preview_course.course_users.exists?(user_id: previewer.id)).to be(true)
+      end
+    end
+
+    context 'a preview submission within the TTL grace period' do
+      let!(:preview_course) { create(:course, preview: true) }
+      let!(:preview_assessment) { create(:assessment, :with_mcq_question, course: preview_course) }
+      let!(:previewer) { create(:user) }
+      let!(:fresh_submission) do
+        create(:submission, :attempting, assessment: preview_assessment,
+                                         course: preview_course, creator: previewer)
+      end
+
+      it 'spares the submission' do
+        expect { subject }.
+          not_to(change { Course::Assessment::Submission.exists?(fresh_submission.id) })
+      end
+    end
+
+    # The highest-value example: proves the job scopes to `preview: true` courses rather than
+    # reaping any old submission it finds.
+    context 'a NON-preview submission of the same age' do
+      let!(:normal_course) { create(:course) }
+      let!(:normal_assessment) { create(:assessment, :with_mcq_question, course: normal_course) }
+      let!(:normal_user) { create(:user) }
+      let!(:aged_normal_submission) do
+        submission = create(:submission, :attempting, assessment: normal_assessment,
+                                                      course: normal_course, creator: normal_user)
+        age!(submission, ago: (ttl + 1.hour).ago)
+        submission
+      end
+
+      it 'spares the non-preview submission' do
+        expect { subject }.
+          not_to(change { Course::Assessment::Submission.exists?(aged_normal_submission.id) })
+      end
+    end
+  end
+end