Pendahuluan: Bug Terburuk di Platform CBT
Di Part 5, saya membahas orang yang sengaja mencoba membobol sistem. Kali ini saya mau cerita soal masalah yang menurut saya lebih menyakitkan bagi sekolah dibanding kebanyakan bug keamanan: siswa sudah selesai ujian, tetapi nilainya salah, hilang, atau tercatat dua kali.
Menariknya, tidak satu pun masalah di bawah ini butuh penyerang. Cukup siswa dengan koneksi lambat, klik dua kali, laptop yang ditutup, atau guru yang mengizinkan ujian ulang. Saya menemukannya saat membaca ExamRunnerService baris demi baris sambil menanyakan satu hal untuk setiap method: apa yang terjadi kalau ini berjalan dua kali bersamaan, atau gagal di tengah jalan?
Semua perbaikannya saya kirim di Pull Request #25: feat/roadmap-hardening, bersama pekerjaan scaling yang nanti saya bahas di Part 7.
Klik diagram untuk membukanya dalam ukuran penuh.
1. Apa yang Salah
| # | Masalah | Yang dilihat siswa atau guru |
|---|---|---|
| 1 | Attempt terakhir dimuat dengan query yang mengharapkan satu baris | Ujian ulang diizinkan → attempt kedua → semua request berikutnya 500 |
| 2 | Attempt yang waktunya habis dinilai, lalu exception me-rollback nilainya | Attempt macet di in_progress selamanya, tanpa nilai |
| 3 | Attempt hanya difinalisasi saat siswa kembali | Siswa menutup tab → tidak ada hasil sampai login lagi |
| 4 | Dua request "mulai" bersamaan | Dua attempt dengan nomor yang sama |
| 5 | Submit dan jalur timeout memfinalisasi attempt yang sama | Dinilai dua kali, dua event EXAM_SUBMITTED |
| 6 | Isian singkat diabaikan grader; satu esai yang dinilai membuat seluruh attempt completed | Nilai salah, penilaian belum selesai tampil sebagai final |
2. Crash Ujian Ulang: Diharapkan Satu Baris, Ditemukan Dua
Repository-nya punya derived query yang mengembalikan Optional:
// Sebelum PR #25
Optional<ExamAttempt> findByExaminationIdAndStudentId(Long examinationId, Long studentId);
Kode ini benar hanya selama setiap siswa punya satu attempt. Begitu guru menyalakan allowRetry dan siswa memulai attempt kedua, Spring Data menemukan dua baris untuk tipe kembalian Optional lalu melempar IncorrectResultSizeDataAccessException. Akibatnya, siswa mendapat error 500 di setiap request ke ujian itu.
Perbaikannya sederhana. Saya minta persis yang dibutuhkan, yaitu attempt terakhir:
/** Attempt terbaru milik siswa (ujian dengan retry bisa punya beberapa). */
Optional<ExamAttempt> findFirstByExaminationIdAndStudentIdOrderByAttemptNumberDesc(Long examinationId, Long studentId);
Method yang sama ternyata menyimpan bug kedua yang lebih senyap. Hanya status completed dan submitted yang dianggap selesai, sehingga attempt berstatus needs_grading atau force_finished malah "dilanjutkan": siswa kembali masuk ke ujian yang sudah tidak bisa dijawab. Sekarang keempat status itu saya hitung sebagai selesai:
/** Status attempt yang tidak lagi menerima jawaban. */
private static final Set<AttemptStatus> FINISHED_STATUSES = EnumSet.of(
AttemptStatus.completed, AttemptStatus.submitted, AttemptStatus.needs_grading, AttemptStatus.force_finished);
Optional<ExamAttempt> latestAttemptOpt = attemptRepository
.findFirstByExaminationIdAndStudentIdOrderByAttemptNumberDesc(examId, student.getId());
if (latestAttemptOpt.isEmpty()) {
attempt = createNewAttempt(exam, student, 1);
} else if (FINISHED_STATUSES.contains(latestAttemptOpt.get().getStatus())) {
if (!exam.isAllowRetry()) {
throw new IllegalStateException("Exam already completed. Retries are not permitted.");
}
attempt = createNewAttempt(exam, student, latestAttemptOpt.get().getAttemptNumber() + 1);
} else {
attempt = latestAttemptOpt.get();
}
3. Bug Rollback: Dinilai, Lalu Terhapus
Semua aturan waktu berjalan di server. Saat siswa menyimpan jawaban setelah deadline, service menilai attempt lalu menolak request. Kode awal saya seperti ini:
// Sebelum PR #25
@Transactional
public void saveAnswer(Long attemptId, SubmitAnswerRequest req, UserPrincipal principal) {
// ...
long remaining = calculateRemainingSeconds(attempt.getExamination(), attempt, LocalDateTime.now());
if (remaining <= 0) {
autoFinalizeAttempt(attempt, attempt.getExamination()); // menulis nilai + status
throw new IllegalStateException("Exam duration has expired. Attempt automatically submitted.");
}
// ...
}
Sekilas kelihatan wajar. Masalahnya, Spring me-rollback method @Transactional untuk setiap unchecked exception. IllegalStateException termasuk unchecked, jadi nilai, status, dan jawaban yang sudah dinilai oleh autoFinalizeAttempt ikut di-rollback. Attempt tetap in_progress, dan request berikutnya mengulang hal yang sama, selamanya. Pesannya bilang "automatically submitted", padahal tidak ada yang tersimpan.
Perbaikannya tetap menolak request, tetapi nilainya di-commit. Saya membuat exception khusus supaya niatnya eksplisit:
/**
* Dilempar setelah attempt yang waktunya habis difinalisasi. Transaksi mendeklarasikan
* noRollbackFor exception ini agar hasil finalisasi tetap ter-commit walaupun request
* klien (simpan jawaban, lanjutkan) ditolak. Dipetakan ke 409 seperti error aturan bisnis lain.
*/
public class AttemptExpiredException extends IllegalStateException { /* ... */ }
// noRollbackFor: saat waktu habis, attempt difinalisasi dan hasilnya harus ter-commit
// walaupun request ditolak dengan AttemptExpiredException.
@Transactional(noRollbackFor = AttemptExpiredException.class)
public void saveAnswer(Long attemptId, SubmitAnswerRequest req, UserPrincipal principal) {
// ...
if (remaining <= 0) {
autoFinalizeAttempt(attempt, attempt.getExamination());
throw new AttemptExpiredException("Exam duration has expired. Attempt automatically submitted.");
}
}
startOrResumeAttempt juga saya beri anotasi yang sama, karena melanjutkan ujian setelah deadline mengikuti pola yang sama. Karena AttemptExpiredException turunan IllegalStateException, GlobalExceptionHandler yang sudah ada tetap memetakannya ke 409 Conflict, jadi frontend tidak perlu diubah sama sekali.
Pelajaran buat saya: kalau sebuah method sengaja menulis sesuatu lalu melempar exception, cek dulu apakah transaksinya akan mempertahankan tulisan itu. Secara default, tidak.
Supaya tidak terulang, saya menulis unit test yang mereproduksi kasus ini:
@Test
void savingAnAnswerAfterTheDeadlineFinalizesTheAttempt() { /* status menjadi completed, AttemptExpiredException dilempar */ }
4. Siswa yang Pergi: Job Kedaluwarsa di Background
Sebelum PR #25, attempt hanya difinalisasi kalau siswa mengirim request lagi setelah deadline. Kalau mereka menutup browser, mati listrik, atau sekadar pergi, attempt tetap in_progress. Di halaman hasil, guru melihat siswa itu seolah masih mengerjakan, dan buku nilainya bolong.
Untuk menutup celah itu, saya membuat ExpiredAttemptFinalizer:
@Component
@RequiredArgsConstructor
@ConditionalOnProperty(name = "app.exam.finalizer.enabled", havingValue = "true", matchIfMissing = true)
public class ExpiredAttemptFinalizer {
private final ExamAttemptRepository attemptRepository;
private final ExamRunnerService examRunnerService;
@Scheduled(
initialDelayString = "${app.exam.finalizer.initial-delay-ms:30000}",
fixedDelayString = "${app.exam.finalizer.interval-ms:60000}")
public void finalizeExpiredAttempts() {
List<Long> expiredIds = attemptRepository.findExpiredInProgressAttemptIds(LocalDateTime.now());
for (Long attemptId : expiredIds) {
try {
examRunnerService.finalizeIfExpired(attemptId);
} catch (ObjectOptimisticLockingFailureException e) {
log.debug("Attempt {} was finalized concurrently by another request or instance", attemptId);
} catch (RuntimeException e) {
// Satu attempt yang bermasalah tidak boleh menghentikan finalisasi yang lain.
log.warn("Could not finalize expired attempt {}: {}", attemptId, e.getMessage());
}
}
}
}
Query-nya memakai aturan deadline yang sama dengan kode Java: mana yang lebih awal antara waktu mulai + durasi dan waktu selesai ujian.
@Query(value = """
SELECT a.id
FROM exam_attempts a
JOIN examinations e ON e.id = a.examination_id
WHERE a.status = 'in_progress'
AND LEAST(a.started_at + make_interval(mins => e.duration_minutes), e.end_at) <= :now
ORDER BY a.id
""", nativeQuery = true)
List<Long> findExpiredInProgressAttemptIds(@Param("now") LocalDateTime now);
Ada tiga keputusan desain yang menurut saya perlu dijelaskan:
- Job hanya mengumpulkan ID. Penilaiannya terjadi di
examRunnerService.finalizeIfExpired(id), yang ber-anotasi@Transactional. Karena dipanggil dari satu bean ke bean lain, pemanggilannya melewati proxy Spring dan setiap attempt mendapat transaksinya sendiri. Kalau loop-nya saya taruh di class yang sama (self-invocation), anotasinya diabaikan dan satu kegagalan bisa me-rollback semuanya. finalizeIfExpiredmemeriksa ulang status di dalam transaksinya (status == in_progressdan sisa waktu ≤ 0). Di antara query dan update, bisa saja siswa sudah submit.- Partial index membuat query tetap murah, karena hanya sedikit baris yang berstatus
in_progress:
CREATE INDEX idx_exam_attempts_in_progress
ON exam_attempts (examination_id)
WHERE status = 'in_progress';
Penjadwalannya saya aktifkan dengan class konfigurasi kecil ber-anotasi @EnableScheduling, dan job-nya bisa diatur atau dimatikan lewat APP_EXAM_FINALIZER_ENABLED dan APP_EXAM_FINALIZER_INTERVAL_MS.
5. Race 1: Klik Dua Kali di "Mulai Ujian"
Bayangkan dua request POST /exams/{id}/start tiba dalam selisih milidetik (klik dua kali, atau ujian terbuka di dua tab). Keduanya membaca "belum ada attempt" dan keduanya meng-insert attempt nomor 1. Aplikasi tidak bisa mencegah ini dengan if, karena kedua request lolos if sebelum salah satunya sempat commit.
Namun, database bisa. Migrasi V3__exam_attempt_integrity.sql menambahkan unique key, setelah lebih dulu menomori ulang duplikat yang sudah ada supaya migrasinya tidak gagal karena data lama:
-- 1) Nomori ulang attempt per (ujian, siswa) sesuai urutan mulai. Tidak ada baris yang dihapus.
WITH ranked AS (
SELECT id,
ROW_NUMBER() OVER (PARTITION BY examination_id, student_id ORDER BY started_at, id) AS rn
FROM exam_attempts
)
UPDATE exam_attempts a
SET attempt_number = r.rn
FROM ranked r
WHERE a.id = r.id
AND a.attempt_number <> r.rn;
-- 2) Satu baris per nomor attempt: dua request "mulai" bersamaan tidak bisa lagi membuat dua attempt.
ALTER TABLE exam_attempts
ADD CONSTRAINT uq_exam_attempt_number UNIQUE (examination_id, student_id, attempt_number);
Request yang kalah sekarang gagal dengan DataIntegrityViolationException. Menampilkan error itu ke siswa jelas membingungkan, karena ujiannya sebenarnya sudah dimulai. Jadi, controller saya buat mencoba ulang sekali:
@PostMapping("/{id}/start")
public ResponseEntity<ApiResponse<ExamStartResponse>> startExam(@PathVariable Long id,
@AuthenticationPrincipal UserPrincipal principal) {
ExamStartResponse response;
try {
response = examRunnerService.startOrResumeAttempt(id, principal);
} catch (DataIntegrityViolationException e) {
// Dua request "mulai" balapan dan unique key menolak insert kedua.
// Attempt pertama sudah ada, jadi mencoba ulang sekali cukup untuk melanjutkannya.
response = examRunnerService.startOrResumeAttempt(id, principal);
}
return ResponseEntity.ok(ApiResponse.success(response, "Exam session started"));
}
Retry-nya sengaja saya letakkan di controller. Transaksi yang gagal sudah ditandai rollback-only, jadi retry di dalam service akan memakai transaksi yang sudah rusak. Dengan memanggil service lagi dari luar, saya mendapat transaksi baru yang melihat attempt yang sudah ter-commit lalu melanjutkannya.
6. Race 2: Submit vs. Job Kedaluwarsa
Race kedua terjadi di antara jalur finalisasi. Siswa menekan "Submit" pukul 10:59:59.8, lalu job kedaluwarsa (atau instance backend lain) mengambil attempt yang sama pukul 11:00:00.1. Keduanya memuatnya sebagai in_progress, keduanya menilai, dan keduanya mengirim EXAM_SUBMITTED.
Di sini saya memilih optimistic locking, bukan distributed lock:
/**
* Optimistic lock: saat submit siswa dan finalizer di background (atau dua instance)
* balapan di attempt yang sama, hanya satu update yang menang dan yang lain gagal, bukan menilai dua kali.
*/
@Version
@Column(nullable = false)
private Long version;
ALTER TABLE exam_attempts ADD COLUMN version BIGINT NOT NULL DEFAULT 0;
Hibernate sekarang menulis UPDATE exam_attempts SET ..., version = 4 WHERE id = ? AND version = 3. Transaksi kedua meng-update nol baris dan mendapat ObjectOptimisticLockingFailureException. Job cukup mencatatnya di log lalu melewatinya, sedangkan request dari user mendapat 409 dengan pesan "reload and try again".
Selain itu, autoFinalizeAttempt langsung kembali kalau attempt sudah bukan in_progress. Ini menangani kasus umum bahkan sebelum terjadi konflik di database:
@Transactional
public ExamAttempt autoFinalizeAttempt(ExamAttempt attempt, Examination exam) {
if (attempt.getStatus() != AttemptStatus.in_progress) {
// Sudah difinalisasi, misalnya oleh job background atau submit paralel.
return attempt;
}
// ...nilai
}
Kenapa tidak pakai lock saja? SELECT ... FOR UPDATE atau lock Redis akan menyerialkan setiap submit, menambah timeout yang perlu disetel, dan meninggalkan lock yang menggantung kalau sebuah instance mati. Konflik di sini jarang (paling banyak beberapa per ujian), jadi menurut saya mendeteksinya lebih murah daripada mencegahnya.
Lima pelanggaran (pindah tab, keluar dari fullscreen) juga memanggil autoFinalizeAttempt, jadi jalur itu ikut terlindungi oleh penjaga yang sama.
7. Aturan Penilaian yang Bisa Di-unit-test
Logika penilaian lama ada di dalam autoFinalizeAttempt, bercampur dengan repository dan perubahan status. Soal isian singkat tidak masuk ke cabang mana pun dari sebuah if, sehingga tidak pernah dinilai: selalu 0 poin, dan tidak pernah ditawarkan ke guru. Di PR #25 saya memindahkan aturannya ke class murni tanpa Spring atau JPA:
public final class AnswerGrader {
/** Pemisah jawaban alternatif di kunci isian singkat, mis. "Jakarta|DKI Jakarta". */
public static final String ALTERNATIVE_SEPARATOR = "|";
public static boolean isAutoGraded(QuestionType type, String correctAnswer) {
return switch (type) {
case multiple_choice, true_false -> true;
case short_answer -> correctAnswer != null && !correctAnswer.isBlank();
case essay -> false;
};
}
public static boolean isCorrect(QuestionType type, String answer, String correctAnswer) {
if (answer == null || correctAnswer == null) return false;
return switch (type) {
case multiple_choice, true_false -> answer.trim().equalsIgnoreCase(correctAnswer.trim());
case short_answer -> {
String given = normalize(answer);
yield !given.isEmpty() && Arrays.stream(correctAnswer.split("\\|"))
.map(AnswerGrader::normalize)
.filter(accepted -> !accepted.isEmpty())
.anyMatch(given::equals);
}
case essay -> false;
};
}
/** Menghapus aksen, huruf kecil, merapatkan spasi, membuang tanda baca di kedua ujung. */
public static String normalize(String value) {
String text = Normalizer.normalize(value, Normalizer.Form.NFD).replaceAll("\\p{M}", "");
text = text.toLowerCase(Locale.ROOT).trim().replaceAll("\\s+", " ");
return text.replaceAll("^[\\p{Punct}\\s]+|[\\p{Punct}\\s]+$", "");
}
/** Nilai 0 sampai 100, dibulatkan ke bawah; 0 jika ujian tidak punya poin. */
public static int scorePercent(int earnedPoints, int possiblePoints) {
return possiblePoints > 0 ? (earnedPoints * 100) / possiblePoints : 0;
}
}
Karena murni, test-nya jadi terbaca seperti spesifikasi:
@Test
void shortAnswerAcceptsAnyAlternativeAfterNormalization() {
String key = "Jakarta|DKI Jakarta";
assertTrue(AnswerGrader.isCorrect(QuestionType.short_answer, " Jakarta. ", key));
assertTrue(AnswerGrader.isCorrect(QuestionType.short_answer, "dki JAKARTA", key));
assertTrue(AnswerGrader.isCorrect(QuestionType.short_answer, "Bogotá", "Bogota"));
assertFalse(AnswerGrader.isCorrect(QuestionType.short_answer, "Bandung", key));
}
Alur penilaian lainnya juga saya perketat:
- Jawaban kosong bernilai 0, bukan "pending". Sebelumnya, esai kosong mendorong attempt ke
needs_gradingpadahal guru tidak punya apa pun untuk dinilai. - Isian singkat tanpa kunci diserahkan ke guru, sama seperti esai (
correct == nullmenandainya sebagai pending). gradeEssaymempertahankan attempt dineeds_gradingsampai semua jawaban pending dinilai. Sebelumnya, menilai esai pertama dari tiga langsung membuat seluruh attemptcompleteddengan nilai parsial.- Poin divalidasi antara 0 dan nilai maksimum soal, soal yang dinilai otomatis tidak bisa ditimpa manual, dan attempt yang masih berjalan tidak bisa dinilai.
@Test
void manualGradingKeepsAttemptPendingUntilEveryEssayIsGraded() {
// dua esai bernilai 4 dan 6 poin
service.gradeEssay(ATTEMPT_ID, 11L, EssayGradingDto.builder().pointsEarned(4).build(), teacherPrincipal);
assertEquals(AttemptStatus.needs_grading, attempt.getStatus());
service.gradeEssay(ATTEMPT_ID, 12L, EssayGradingDto.builder().pointsEarned(3).feedback("Add an example").build(), teacherPrincipal);
assertEquals(AttemptStatus.completed, attempt.getStatus());
assertEquals(70, attempt.getScore()); // 7 dari 10 poin
}
8. Event Monitor Live Hanya Setelah Commit
Ada satu detail integritas lagi: monitor live guru. Event seperti ANSWER_SAVED dan EXAM_SUBMITTED dulu dikirim dengan SimpMessagingTemplate di tengah transaksi. Kalau transaksinya kemudian di-rollback (dan seperti di bagian 3, itu memang terjadi), guru sudah telanjur melihat nilai yang sebenarnya tidak ada.
Sekarang ExamRealtimeService mendaftarkan event dulu dan baru mengirimnya setelah commit:
if (TransactionSynchronizationManager.isSynchronizationActive()) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCommit() {
dispatch(envelope);
}
});
} else {
dispatch(envelope);
}
Method dispatch ini juga menjadi tempat fan-out Redis untuk beberapa instance. Bagian itu saya bahas di Part 7.
9. Checklist
| Aturan | Cara penegakannya |
|---|---|
| Ujian ulang tidak pernah crash | findFirst...OrderByAttemptNumberDesc |
| Attempt yang selesai tidak bisa dilanjutkan | FINISHED_STATUSES mencakup 4 status |
| Request terlambat tetap menyimpan nilai | AttemptExpiredException + noRollbackFor |
| Attempt yang ditinggal tetap dapat hasil | ExpiredAttemptFinalizer tiap 60 detik, satu transaksi per attempt |
| Tidak ada nomor attempt ganda | UNIQUE (examination_id, student_id, attempt_number) + satu retry |
| Tidak ada penilaian ganda | @Version + early return di autoFinalizeAttempt |
| Isian singkat dinilai adil | AnswerGrader.normalize dan alternatif ` |
| Penilaian manual tuntas sebelum "completed" | Cek pending di gradeEssay |
| Monitor tidak menampilkan data yang di-rollback | Dispatch afterCommit |
Kesimpulan & Selanjutnya
Kalau saya lihat lagi, tidak satu pun bug ini muncul di tes manual singkat dengan satu user dan koneksi cepat. Semuanya baru muncul saat ada ujian ulang, klik dua kali, tab yang ditutup, dan dua jalur kode yang memfinalisasi attempt yang sama. Yang akhirnya memperbaiki semuanya adalah jaminan dari database (unique key, kolom version, batas transaksi), bukan tambahan if.
Kolom @Version dan transaksi per attempt juga menyiapkan langkah saya berikutnya: menjalankan lebih dari satu instance backend. Di Part 7, saya memindahkan refresh token ke cookie httpOnly, memberi SPA Content-Security-Policy, dan membuat rate limit, event live, serta upload file bisa bekerja di beberapa instance.
- Demo live: https://spring-elearning.mfarim.com
- Source code: github.com/mfarim/spring-elearning-react
- Pull request: #25

Ditulis oleh Muhammad Fari Madyan
Senior Full Stack Engineer dan co-founder LampungDev. Saya menuliskan apa yang saya bangun supaya orang lain bisa ikut belajar.

