diff --git a/src/main/java/com/study/course_registration/application/idempotency/CleanupIdempotencyUseCase.java b/src/main/java/com/study/course_registration/application/idempotency/CleanupIdempotencyUseCase.java deleted file mode 100644 index 6e2e151..0000000 --- a/src/main/java/com/study/course_registration/application/idempotency/CleanupIdempotencyUseCase.java +++ /dev/null @@ -1,24 +0,0 @@ -package com.study.course_registration.application.idempotency; - -import java.time.Clock; - -import org.springframework.stereotype.Service; -import org.springframework.transaction.annotation.Transactional; - -import com.study.course_registration.application.idempotency.port.IdempotencyPort; - -@Service -public class CleanupIdempotencyUseCase { - private final Clock clock; - private final IdempotencyPort idempotencies; - - public CleanupIdempotencyUseCase(Clock clock, IdempotencyPort idempotencies) { - this.clock = clock; - this.idempotencies = idempotencies; - } - - @Transactional - public void execute() { - idempotencies.deleteExpired(clock.instant()); - } -} diff --git a/src/main/java/com/study/course_registration/application/idempotency/port/IdempotencyPort.java b/src/main/java/com/study/course_registration/application/idempotency/port/IdempotencyPort.java deleted file mode 100644 index e9576e4..0000000 --- a/src/main/java/com/study/course_registration/application/idempotency/port/IdempotencyPort.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.study.course_registration.application.idempotency.port; - -import java.time.Instant; -import java.util.Optional; - -public interface IdempotencyPort { - Optional findActive(String userId, String key, Instant now); - - void deleteExpiredKey(String userId, String key, Instant now); - - void deleteExpired(Instant now); - - void save(SaveCommand command); - - record ReplayRecord( - String registrationId, - String userId, - String lessonId, - String lessonName, - String subjectCode, - int credit, - Instant registeredAt, - int totalCredits) { - } - - record SaveCommand( - String userId, - String lessonId, - String registrationId, - String key, - int totalCredits, - Instant expiresAt) { - } -} diff --git a/src/main/java/com/study/course_registration/application/lesson/GetLessonQuery.java b/src/main/java/com/study/course_registration/application/lesson/GetLessonQuery.java index 387017f..d0086c7 100644 --- a/src/main/java/com/study/course_registration/application/lesson/GetLessonQuery.java +++ b/src/main/java/com/study/course_registration/application/lesson/GetLessonQuery.java @@ -4,7 +4,7 @@ import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import com.study.course_registration.application.lesson.port.LessonQueryPort; -import com.study.course_registration.application.lesson.port.LessonQueryPort.LessonDetailView; +import com.study.course_registration.application.lesson.model.LessonDetailView; import com.study.course_registration.failure.ResourceNotFound; @Service diff --git a/src/main/java/com/study/course_registration/application/lesson/GetLessonsQuery.java b/src/main/java/com/study/course_registration/application/lesson/GetLessonsQuery.java index 25a5f4a..253681a 100644 --- a/src/main/java/com/study/course_registration/application/lesson/GetLessonsQuery.java +++ b/src/main/java/com/study/course_registration/application/lesson/GetLessonsQuery.java @@ -7,8 +7,8 @@ import org.springframework.transaction.annotation.Transactional; import com.study.course_registration.application.lesson.LessonListResult.LessonItemResult; import com.study.course_registration.application.lesson.port.LessonQueryPort; -import com.study.course_registration.application.lesson.port.LessonQueryPort.LessonListView; -import com.study.course_registration.application.lesson.port.LessonQueryPort.LessonPage; +import com.study.course_registration.application.lesson.model.LessonListView; +import com.study.course_registration.application.lesson.model.LessonPage; import com.study.course_registration.application.semester.SemesterSelectionPolicy; import com.study.course_registration.application.semester.SemesterSnapshot; diff --git a/src/main/java/com/study/course_registration/application/lesson/model/LessonDetailView.java b/src/main/java/com/study/course_registration/application/lesson/model/LessonDetailView.java new file mode 100644 index 0000000..2515131 --- /dev/null +++ b/src/main/java/com/study/course_registration/application/lesson/model/LessonDetailView.java @@ -0,0 +1,29 @@ +package com.study.course_registration.application.lesson.model; + +import java.time.Instant; +import java.util.List; + +import com.study.course_registration.domain.schedule.ScheduleSlot; +import com.study.course_registration.enums.UserRole; + +public record LessonDetailView( + String lessonId, + String lessonName, + String subjectCode, + String subjectName, + String subjectDescription, + int credit, + String professorName, + String semesterName, + int capacity, + long enrolledCount, + Long minGrade, + UserRole allowedRole, + Instant registrationStartAt, + Instant registrationEndAt, + List schedules) { + + public LessonDetailView { + schedules = List.copyOf(schedules); + } +} diff --git a/src/main/java/com/study/course_registration/application/lesson/model/LessonListView.java b/src/main/java/com/study/course_registration/application/lesson/model/LessonListView.java new file mode 100644 index 0000000..529f0eb --- /dev/null +++ b/src/main/java/com/study/course_registration/application/lesson/model/LessonListView.java @@ -0,0 +1,24 @@ +package com.study.course_registration.application.lesson.model; + +import java.util.List; + +import com.study.course_registration.domain.schedule.ScheduleSlot; +import com.study.course_registration.enums.UserRole; + +public record LessonListView( + String lessonId, + String lessonName, + String subjectCode, + String subjectName, + int credit, + String professorName, + int capacity, + long enrolledCount, + Long minGrade, + UserRole allowedRole, + List schedules) { + + public LessonListView { + schedules = List.copyOf(schedules); + } +} diff --git a/src/main/java/com/study/course_registration/application/lesson/model/LessonPage.java b/src/main/java/com/study/course_registration/application/lesson/model/LessonPage.java new file mode 100644 index 0000000..330b615 --- /dev/null +++ b/src/main/java/com/study/course_registration/application/lesson/model/LessonPage.java @@ -0,0 +1,12 @@ +package com.study.course_registration.application.lesson.model; + +import java.util.List; + +public record LessonPage( + List lessons, + long totalElements) { + + public LessonPage { + lessons = List.copyOf(lessons); + } +} diff --git a/src/main/java/com/study/course_registration/application/lesson/port/LessonQueryPort.java b/src/main/java/com/study/course_registration/application/lesson/port/LessonQueryPort.java index 9ca6651..8e2b766 100644 --- a/src/main/java/com/study/course_registration/application/lesson/port/LessonQueryPort.java +++ b/src/main/java/com/study/course_registration/application/lesson/port/LessonQueryPort.java @@ -1,51 +1,12 @@ package com.study.course_registration.application.lesson.port; -import java.time.Instant; -import java.util.List; import java.util.Optional; -import com.study.course_registration.domain.schedule.ScheduleSlot; -import com.study.course_registration.enums.UserRole; +import com.study.course_registration.application.lesson.model.LessonDetailView; +import com.study.course_registration.application.lesson.model.LessonPage; public interface LessonQueryPort { LessonPage findPage(String semesterId, String subjectId, int page, int size); Optional findDetailed(String lessonId); - - record LessonPage( - List lessons, - long totalElements) { - } - - record LessonListView( - String lessonId, - String lessonName, - String subjectCode, - String subjectName, - int credit, - String professorName, - int capacity, - long enrolledCount, - Long minGrade, - UserRole allowedRole, - List schedules) { - } - - record LessonDetailView( - String lessonId, - String lessonName, - String subjectCode, - String subjectName, - String subjectDescription, - int credit, - String professorName, - String semesterName, - int capacity, - long enrolledCount, - Long minGrade, - UserRole allowedRole, - Instant registrationStartAt, - Instant registrationEndAt, - List schedules) { - } } diff --git a/src/main/java/com/study/course_registration/application/registration/CancelRegistrationUseCase.java b/src/main/java/com/study/course_registration/application/registration/CancelRegistrationUseCase.java index b0e4344..ad109b3 100644 --- a/src/main/java/com/study/course_registration/application/registration/CancelRegistrationUseCase.java +++ b/src/main/java/com/study/course_registration/application/registration/CancelRegistrationUseCase.java @@ -6,6 +6,7 @@ import java.time.Instant; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; +import com.study.course_registration.application.registration.model.CancellationTarget; import com.study.course_registration.application.registration.port.CancellationContextLoader; import com.study.course_registration.application.registration.port.RegistrationWriter; import com.study.course_registration.domain.registration.CancellationContext; @@ -32,11 +33,13 @@ public class CancelRegistrationUseCase { @Transactional public void execute(String userId, String registrationId) { - CancellationContext context = contexts.load(registrationId); + CancellationTarget target = contexts.findTarget(registrationId); - if (!context.ownerUserId().equals(userId)) { + if (!target.ownerUserId().equals(userId)) { throw AuthorizationFailure.registrationForbidden(); } + + CancellationContext context = contexts.lock(target); if (context.canceled()) { return; } diff --git a/src/main/java/com/study/course_registration/application/registration/GetRegistrationsQuery.java b/src/main/java/com/study/course_registration/application/registration/GetRegistrationsQuery.java index 8485f67..824ad67 100644 --- a/src/main/java/com/study/course_registration/application/registration/GetRegistrationsQuery.java +++ b/src/main/java/com/study/course_registration/application/registration/GetRegistrationsQuery.java @@ -7,7 +7,7 @@ import org.springframework.transaction.annotation.Transactional; import com.study.course_registration.application.registration.RegistrationListResult.RegistrationItemResult; import com.study.course_registration.application.registration.port.RegistrationReader; -import com.study.course_registration.application.registration.port.RegistrationReader.ActiveRegistrationView; +import com.study.course_registration.application.registration.model.ActiveRegistrationView; import com.study.course_registration.application.semester.SemesterSelectionPolicy; import com.study.course_registration.application.semester.SemesterSnapshot; import com.study.course_registration.failure.ResourceNotFound; diff --git a/src/main/java/com/study/course_registration/application/registration/RegisterCourseUseCase.java b/src/main/java/com/study/course_registration/application/registration/RegisterCourseUseCase.java index ef40980..370d319 100644 --- a/src/main/java/com/study/course_registration/application/registration/RegisterCourseUseCase.java +++ b/src/main/java/com/study/course_registration/application/registration/RegisterCourseUseCase.java @@ -6,14 +6,14 @@ import java.time.Instant; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; -import com.study.course_registration.application.idempotency.IdempotencyCoordinator; -import com.study.course_registration.application.idempotency.IdempotencyCoordinator.Decision; -import com.study.course_registration.application.idempotency.port.IdempotencyPort.ReplayRecord; -import com.study.course_registration.application.registration.port.RegistrationDecisionContextLoader; +import com.study.course_registration.application.registration.idempotency.IdempotencyCoordinator; +import com.study.course_registration.application.registration.idempotency.IdempotencyCoordinator.Decision; +import com.study.course_registration.application.registration.idempotency.model.IdempotencyReplay; +import com.study.course_registration.application.registration.port.RegistrationDecisionSnapshotLoader; import com.study.course_registration.application.registration.port.RegistrationExecutionScopeLoader; import com.study.course_registration.application.registration.port.RegistrationWriter; -import com.study.course_registration.application.registration.port.RegistrationWriter.RegistrationRecord; -import com.study.course_registration.domain.registration.RegistrationContext; +import com.study.course_registration.application.registration.model.RegistrationRecord; +import com.study.course_registration.domain.registration.RegistrationDecisionSnapshot; import com.study.course_registration.domain.registration.RegistrationExecutionScope; import com.study.course_registration.domain.registration.RegistrationPolicy; import com.study.course_registration.domain.registration.RegistrationWindowGuard; @@ -22,7 +22,7 @@ import com.study.course_registration.domain.registration.RegistrationWindowGuard public class RegisterCourseUseCase { private final Clock clock; private final RegistrationExecutionScopeLoader executionScopes; - private final RegistrationDecisionContextLoader decisionContexts; + private final RegistrationDecisionSnapshotLoader decisionSnapshots; private final RegistrationWriter registrations; private final RegistrationPolicy registrationPolicy; private final RegistrationWindowGuard registrationWindowGuard; @@ -31,14 +31,14 @@ public class RegisterCourseUseCase { public RegisterCourseUseCase( Clock clock, RegistrationExecutionScopeLoader executionScopes, - RegistrationDecisionContextLoader decisionContexts, + RegistrationDecisionSnapshotLoader decisionSnapshots, RegistrationWriter registrations, RegistrationPolicy registrationPolicy, RegistrationWindowGuard registrationWindowGuard, IdempotencyCoordinator idempotency) { this.clock = clock; this.executionScopes = executionScopes; - this.decisionContexts = decisionContexts; + this.decisionSnapshots = decisionSnapshots; this.registrations = registrations; this.registrationPolicy = registrationPolicy; this.registrationWindowGuard = registrationWindowGuard; @@ -62,7 +62,9 @@ public class RegisterCourseUseCase { return replay(decision.replay().orElseThrow()); } - RegistrationContext context = decisionContexts.load(scope, requestTime); + executionScopes.lockLesson(scope); + + RegistrationDecisionSnapshot context = decisionSnapshots.load(scope, requestTime); registrationPolicy.validate(context); registrationWindowGuard.verify(context.lesson(), clock.instant()); @@ -89,7 +91,7 @@ public class RegisterCourseUseCase { totalCredits); } - private static RegistrationResult replay(ReplayRecord stored) { + private static RegistrationResult replay(IdempotencyReplay stored) { return new RegistrationResult( stored.registrationId(), stored.userId(), diff --git a/src/main/java/com/study/course_registration/application/registration/idempotency/CleanupIdempotencyUseCase.java b/src/main/java/com/study/course_registration/application/registration/idempotency/CleanupIdempotencyUseCase.java new file mode 100644 index 0000000..378625e --- /dev/null +++ b/src/main/java/com/study/course_registration/application/registration/idempotency/CleanupIdempotencyUseCase.java @@ -0,0 +1,30 @@ +package com.study.course_registration.application.registration.idempotency; + +import java.time.Clock; + +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.study.course_registration.application.registration.idempotency.port.IdempotencyPort; + +@Service +public class CleanupIdempotencyUseCase { + private final Clock clock; + private final IdempotencyPort idempotencies; + private final int batchSize; + + public CleanupIdempotencyUseCase( + Clock clock, + IdempotencyPort idempotencies, + @Value("${app.idempotency.cleanup-batch-size:500}") int batchSize) { + this.clock = clock; + this.idempotencies = idempotencies; + this.batchSize = batchSize; + } + + @Transactional + public int execute() { + return idempotencies.deleteExpiredBatch(clock.instant(), batchSize); + } +} diff --git a/src/main/java/com/study/course_registration/application/registration/idempotency/IdempotencyConflict.java b/src/main/java/com/study/course_registration/application/registration/idempotency/IdempotencyConflict.java new file mode 100644 index 0000000..02f7334 --- /dev/null +++ b/src/main/java/com/study/course_registration/application/registration/idempotency/IdempotencyConflict.java @@ -0,0 +1,15 @@ +package com.study.course_registration.application.registration.idempotency; + +import com.study.course_registration.enums.RegistrationErrorCode; +import com.study.course_registration.failure.ApplicationFailure; + +public final class IdempotencyConflict extends ApplicationFailure { + private IdempotencyConflict(String message) { + super(RegistrationErrorCode.IDEMPOTENCY_KEY_REUSED, message); + } + + public static IdempotencyConflict reusedForDifferentLesson() { + return new IdempotencyConflict( + "동일한 Idempotency-Key를 다른 강의에 사용할 수 없습니다."); + } +} diff --git a/src/main/java/com/study/course_registration/application/idempotency/IdempotencyCoordinator.java b/src/main/java/com/study/course_registration/application/registration/idempotency/IdempotencyCoordinator.java similarity index 63% rename from src/main/java/com/study/course_registration/application/idempotency/IdempotencyCoordinator.java rename to src/main/java/com/study/course_registration/application/registration/idempotency/IdempotencyCoordinator.java index 022508b..25be48c 100644 --- a/src/main/java/com/study/course_registration/application/idempotency/IdempotencyCoordinator.java +++ b/src/main/java/com/study/course_registration/application/registration/idempotency/IdempotencyCoordinator.java @@ -1,4 +1,4 @@ -package com.study.course_registration.application.idempotency; +package com.study.course_registration.application.registration.idempotency; import java.time.Instant; import java.util.Optional; @@ -6,12 +6,11 @@ import java.util.Optional; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; -import com.study.course_registration.application.idempotency.port.IdempotencyPort; -import com.study.course_registration.application.idempotency.port.IdempotencyPort.ReplayRecord; -import com.study.course_registration.application.idempotency.port.IdempotencyPort.SaveCommand; -import com.study.course_registration.application.registration.port.RegistrationWriter.RegistrationRecord; -import com.study.course_registration.domain.registration.RegistrationContext; -import com.study.course_registration.failure.BusinessRejection; +import com.study.course_registration.application.registration.idempotency.model.IdempotencyReplay; +import com.study.course_registration.application.registration.idempotency.model.IdempotencySaveCommand; +import com.study.course_registration.application.registration.idempotency.port.IdempotencyPort; +import com.study.course_registration.application.registration.model.RegistrationRecord; +import com.study.course_registration.domain.registration.RegistrationDecisionSnapshot; import com.study.course_registration.failure.RequestValidationFailure; @Component @@ -21,7 +20,7 @@ public class IdempotencyCoordinator { public IdempotencyCoordinator( IdempotencyPort idempotencies, - @Value("$" + "{app.idempotency.ttl-seconds:86400}") long ttlSeconds) { + @Value("${app.idempotency.ttl-seconds:86400}") long ttlSeconds) { this.idempotencies = idempotencies; this.ttlSeconds = ttlSeconds; } @@ -33,21 +32,21 @@ public class IdempotencyCoordinator { } idempotencies.deleteExpiredKey(userId, key, now); - Optional previous = idempotencies.findActive(userId, key, now); + Optional previous = idempotencies.findActive(userId, key, now); if (previous.isEmpty()) { return Decision.newRequest(key); } - ReplayRecord stored = previous.get(); + IdempotencyReplay stored = previous.get(); if (!stored.lessonId().equals(lessonId)) { - throw BusinessRejection.idempotencyKeyReused(); + throw IdempotencyConflict.reusedForDifferentLesson(); } return Decision.replay(key, stored); } public void record( Decision decision, - RegistrationContext context, + RegistrationDecisionSnapshot snapshot, RegistrationRecord registration, int totalCredits, Instant now) { @@ -55,11 +54,15 @@ public class IdempotencyCoordinator { return; } - idempotencies.save(new SaveCommand( - context.user().id(), - context.lesson().id(), + idempotencies.save(new IdempotencySaveCommand( + snapshot.user().id(), + snapshot.lesson().id(), registration.registrationId(), decision.key(), + snapshot.lesson().name(), + snapshot.lesson().subjectCode(), + snapshot.lesson().subjectCredit(), + registration.registeredAt(), totalCredits, now.plusSeconds(ttlSeconds))); } @@ -77,7 +80,7 @@ public class IdempotencyCoordinator { public record Decision( String key, - Optional replay) { + Optional replay) { static Decision withoutKey() { return new Decision(null, Optional.empty()); @@ -87,7 +90,7 @@ public class IdempotencyCoordinator { return new Decision(key, Optional.empty()); } - static Decision replay(String key, ReplayRecord stored) { + static Decision replay(String key, IdempotencyReplay stored) { return new Decision(key, Optional.of(stored)); } } diff --git a/src/main/java/com/study/course_registration/application/registration/idempotency/model/IdempotencyReplay.java b/src/main/java/com/study/course_registration/application/registration/idempotency/model/IdempotencyReplay.java new file mode 100644 index 0000000..6a36dc8 --- /dev/null +++ b/src/main/java/com/study/course_registration/application/registration/idempotency/model/IdempotencyReplay.java @@ -0,0 +1,14 @@ +package com.study.course_registration.application.registration.idempotency.model; + +import java.time.Instant; + +public record IdempotencyReplay( + String registrationId, + String userId, + String lessonId, + String lessonName, + String subjectCode, + int credit, + Instant registeredAt, + int totalCredits) { +} diff --git a/src/main/java/com/study/course_registration/application/registration/idempotency/model/IdempotencySaveCommand.java b/src/main/java/com/study/course_registration/application/registration/idempotency/model/IdempotencySaveCommand.java new file mode 100644 index 0000000..1f2157d --- /dev/null +++ b/src/main/java/com/study/course_registration/application/registration/idempotency/model/IdempotencySaveCommand.java @@ -0,0 +1,16 @@ +package com.study.course_registration.application.registration.idempotency.model; + +import java.time.Instant; + +public record IdempotencySaveCommand( + String userId, + String lessonId, + String registrationId, + String key, + String lessonName, + String subjectCode, + int credit, + Instant registeredAt, + int totalCredits, + Instant expiresAt) { +} diff --git a/src/main/java/com/study/course_registration/application/registration/idempotency/port/IdempotencyPort.java b/src/main/java/com/study/course_registration/application/registration/idempotency/port/IdempotencyPort.java new file mode 100644 index 0000000..7edc01c --- /dev/null +++ b/src/main/java/com/study/course_registration/application/registration/idempotency/port/IdempotencyPort.java @@ -0,0 +1,17 @@ +package com.study.course_registration.application.registration.idempotency.port; + +import java.time.Instant; +import java.util.Optional; + +import com.study.course_registration.application.registration.idempotency.model.IdempotencyReplay; +import com.study.course_registration.application.registration.idempotency.model.IdempotencySaveCommand; + +public interface IdempotencyPort { + Optional findActive(String userId, String key, Instant now); + + void deleteExpiredKey(String userId, String key, Instant now); + + int deleteExpiredBatch(Instant now, int batchSize); + + void save(IdempotencySaveCommand command); +} diff --git a/src/main/java/com/study/course_registration/application/registration/model/ActiveRegistrationView.java b/src/main/java/com/study/course_registration/application/registration/model/ActiveRegistrationView.java new file mode 100644 index 0000000..8242393 --- /dev/null +++ b/src/main/java/com/study/course_registration/application/registration/model/ActiveRegistrationView.java @@ -0,0 +1,22 @@ +package com.study.course_registration.application.registration.model; + +import java.time.Instant; +import java.util.List; + +import com.study.course_registration.domain.schedule.ScheduleSlot; + +public record ActiveRegistrationView( + String registrationId, + String lessonId, + String lessonName, + String subjectCode, + String subjectName, + int credit, + String professorName, + List schedules, + Instant registeredAt) { + + public ActiveRegistrationView { + schedules = List.copyOf(schedules); + } +} diff --git a/src/main/java/com/study/course_registration/application/registration/model/CancellationTarget.java b/src/main/java/com/study/course_registration/application/registration/model/CancellationTarget.java new file mode 100644 index 0000000..1f11257 --- /dev/null +++ b/src/main/java/com/study/course_registration/application/registration/model/CancellationTarget.java @@ -0,0 +1,7 @@ +package com.study.course_registration.application.registration.model; + +public record CancellationTarget( + String registrationId, + String ownerUserId, + String lessonId) { +} diff --git a/src/main/java/com/study/course_registration/application/registration/model/RegistrationRecord.java b/src/main/java/com/study/course_registration/application/registration/model/RegistrationRecord.java new file mode 100644 index 0000000..4ba58c6 --- /dev/null +++ b/src/main/java/com/study/course_registration/application/registration/model/RegistrationRecord.java @@ -0,0 +1,8 @@ +package com.study.course_registration.application.registration.model; + +import java.time.Instant; + +public record RegistrationRecord( + String registrationId, + Instant registeredAt) { +} diff --git a/src/main/java/com/study/course_registration/application/registration/port/CancellationContextLoader.java b/src/main/java/com/study/course_registration/application/registration/port/CancellationContextLoader.java index 25733ea..e96c473 100644 --- a/src/main/java/com/study/course_registration/application/registration/port/CancellationContextLoader.java +++ b/src/main/java/com/study/course_registration/application/registration/port/CancellationContextLoader.java @@ -1,7 +1,10 @@ package com.study.course_registration.application.registration.port; +import com.study.course_registration.application.registration.model.CancellationTarget; import com.study.course_registration.domain.registration.CancellationContext; public interface CancellationContextLoader { - CancellationContext load(String registrationId); + CancellationTarget findTarget(String registrationId); + + CancellationContext lock(CancellationTarget target); } diff --git a/src/main/java/com/study/course_registration/application/registration/port/RegistrationDecisionContextLoader.java b/src/main/java/com/study/course_registration/application/registration/port/RegistrationDecisionSnapshotLoader.java similarity index 60% rename from src/main/java/com/study/course_registration/application/registration/port/RegistrationDecisionContextLoader.java rename to src/main/java/com/study/course_registration/application/registration/port/RegistrationDecisionSnapshotLoader.java index 95ae2f1..45292e8 100644 --- a/src/main/java/com/study/course_registration/application/registration/port/RegistrationDecisionContextLoader.java +++ b/src/main/java/com/study/course_registration/application/registration/port/RegistrationDecisionSnapshotLoader.java @@ -2,9 +2,9 @@ package com.study.course_registration.application.registration.port; import java.time.Instant; -import com.study.course_registration.domain.registration.RegistrationContext; +import com.study.course_registration.domain.registration.RegistrationDecisionSnapshot; import com.study.course_registration.domain.registration.RegistrationExecutionScope; -public interface RegistrationDecisionContextLoader { - RegistrationContext load(RegistrationExecutionScope scope, Instant now); +public interface RegistrationDecisionSnapshotLoader { + RegistrationDecisionSnapshot load(RegistrationExecutionScope scope, Instant now); } diff --git a/src/main/java/com/study/course_registration/application/registration/port/RegistrationExecutionScopeLoader.java b/src/main/java/com/study/course_registration/application/registration/port/RegistrationExecutionScopeLoader.java index 73d02a6..eac9126 100644 --- a/src/main/java/com/study/course_registration/application/registration/port/RegistrationExecutionScopeLoader.java +++ b/src/main/java/com/study/course_registration/application/registration/port/RegistrationExecutionScopeLoader.java @@ -4,4 +4,6 @@ import com.study.course_registration.domain.registration.RegistrationExecutionSc public interface RegistrationExecutionScopeLoader { RegistrationExecutionScope open(String userId, String lessonId); + + void lockLesson(RegistrationExecutionScope scope); } diff --git a/src/main/java/com/study/course_registration/application/registration/port/RegistrationReader.java b/src/main/java/com/study/course_registration/application/registration/port/RegistrationReader.java index c9f134c..a960f31 100644 --- a/src/main/java/com/study/course_registration/application/registration/port/RegistrationReader.java +++ b/src/main/java/com/study/course_registration/application/registration/port/RegistrationReader.java @@ -1,24 +1,11 @@ package com.study.course_registration.application.registration.port; -import java.time.Instant; import java.util.List; -import com.study.course_registration.domain.schedule.ScheduleSlot; +import com.study.course_registration.application.registration.model.ActiveRegistrationView; public interface RegistrationReader { boolean userExists(String userId); List findActive(String userId, String semesterId); - - record ActiveRegistrationView( - String registrationId, - String lessonId, - String lessonName, - String subjectCode, - String subjectName, - int credit, - String professorName, - List schedules, - Instant registeredAt) { - } } diff --git a/src/main/java/com/study/course_registration/application/registration/port/RegistrationWriter.java b/src/main/java/com/study/course_registration/application/registration/port/RegistrationWriter.java index f3138b4..ea2b29f 100644 --- a/src/main/java/com/study/course_registration/application/registration/port/RegistrationWriter.java +++ b/src/main/java/com/study/course_registration/application/registration/port/RegistrationWriter.java @@ -2,13 +2,10 @@ package com.study.course_registration.application.registration.port; import java.time.Instant; +import com.study.course_registration.application.registration.model.RegistrationRecord; + public interface RegistrationWriter { RegistrationRecord create(String userId, String lessonId); void cancel(String registrationId, Instant canceledAt); - - record RegistrationRecord( - String registrationId, - Instant registeredAt) { - } } diff --git a/src/main/java/com/study/course_registration/config/DomainPolicyConfig.java b/src/main/java/com/study/course_registration/config/DomainPolicyConfig.java index d2f3442..f12122e 100644 --- a/src/main/java/com/study/course_registration/config/DomainPolicyConfig.java +++ b/src/main/java/com/study/course_registration/config/DomainPolicyConfig.java @@ -9,9 +9,6 @@ import com.study.course_registration.domain.registration.rule.AlreadyRegisteredR import com.study.course_registration.domain.registration.rule.CapacityRule; import com.study.course_registration.domain.registration.rule.CreditLimitRule; import com.study.course_registration.domain.registration.rule.DuplicateSubjectRule; -import com.study.course_registration.domain.registration.rule.GradeEligibilityRule; -import com.study.course_registration.domain.registration.rule.RegistrationPeriodRule; -import com.study.course_registration.domain.registration.rule.RoleEligibilityRule; import com.study.course_registration.domain.registration.rule.ScheduleAvailabilityRule; import com.study.course_registration.domain.registration.rule.ScheduleConflictRule; import com.study.course_registration.domain.schedule.LessonSchedulePolicy; @@ -37,9 +34,6 @@ public class DomainPolicyConfig { @Bean RegistrationPolicy registrationPolicy(ScheduleConflictChecker checker) { return new RegistrationPolicy( - new RegistrationPeriodRule(), - new GradeEligibilityRule(), - new RoleEligibilityRule(), new AlreadyRegisteredRule(), new DuplicateSubjectRule(), new ScheduleAvailabilityRule(), diff --git a/src/main/java/com/study/course_registration/domain/registration/CancellationContext.java b/src/main/java/com/study/course_registration/domain/registration/CancellationContext.java index 9b218d9..e62aec5 100644 --- a/src/main/java/com/study/course_registration/domain/registration/CancellationContext.java +++ b/src/main/java/com/study/course_registration/domain/registration/CancellationContext.java @@ -1,7 +1,6 @@ package com.study.course_registration.domain.registration; public record CancellationContext( - String ownerUserId, String registrationId, LessonPolicySnapshot lesson, boolean canceled) { diff --git a/src/main/java/com/study/course_registration/domain/registration/LessonPolicySnapshot.java b/src/main/java/com/study/course_registration/domain/registration/LessonPolicySnapshot.java index b4e67c4..b47c172 100644 --- a/src/main/java/com/study/course_registration/domain/registration/LessonPolicySnapshot.java +++ b/src/main/java/com/study/course_registration/domain/registration/LessonPolicySnapshot.java @@ -1,6 +1,7 @@ package com.study.course_registration.domain.registration; import java.time.Instant; +import java.util.Objects; import com.study.course_registration.enums.UserRole; @@ -17,4 +18,46 @@ public record LessonPolicySnapshot( int capacity, Long minGrade, UserRole allowedRole) { + + public LessonPolicySnapshot { + Objects.requireNonNull(id, "id"); + Objects.requireNonNull(name, "name"); + Objects.requireNonNull(subjectId, "subjectId"); + Objects.requireNonNull(subjectCode, "subjectCode"); + Objects.requireNonNull(semesterId, "semesterId"); + Objects.requireNonNull(registrationStartAt, "registrationStartAt"); + Objects.requireNonNull(registrationEndAt, "registrationEndAt"); + if (subjectCredit < 1) { + throw new IllegalArgumentException("subjectCredit must be at least 1"); + } + if (maxCredits < 1) { + throw new IllegalArgumentException("maxCredits must be at least 1"); + } + if (capacity < 1) { + throw new IllegalArgumentException("capacity must be at least 1"); + } + if (minGrade != null && minGrade < 1) { + throw new IllegalArgumentException("minGrade must be at least 1"); + } + if (!registrationStartAt.isBefore(registrationEndAt)) { + throw new IllegalArgumentException("registrationStartAt must be before registrationEndAt"); + } + } + + public void verifyRegistrationWindow(Instant now) { + Objects.requireNonNull(now, "now"); + if (now.isBefore(registrationStartAt) || now.isAfter(registrationEndAt)) { + throw RegistrationRejection.registrationPeriodClosed(); + } + } + + public void verifyStudentEligibility(UserProfile user) { + Objects.requireNonNull(user, "user"); + if (minGrade != null && user.grade() < minGrade) { + throw RegistrationRejection.notEligibleGrade(user.grade(), minGrade); + } + if (allowedRole != null && user.role() != allowedRole) { + throw RegistrationRejection.notEligibleRole(allowedRole); + } + } } diff --git a/src/main/java/com/study/course_registration/domain/registration/RegistrationContext.java b/src/main/java/com/study/course_registration/domain/registration/RegistrationContext.java deleted file mode 100644 index 0fcaebc..0000000 --- a/src/main/java/com/study/course_registration/domain/registration/RegistrationContext.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.study.course_registration.domain.registration; - -import java.time.Instant; -import java.util.List; -import java.util.Map; - -import com.study.course_registration.domain.schedule.ScheduleSlot; - -public record RegistrationContext( - UserProfile user, - LessonPolicySnapshot lesson, - List activeRegistrations, - Map> schedulesByLessonId, - long enrolledCount, - Instant now) { - - public List candidateSchedules() { - return schedulesByLessonId.getOrDefault(lesson.id(), List.of()); - } - - public List schedulesOf(ActiveRegistrationSnapshot registration) { - return schedulesByLessonId.getOrDefault(registration.lessonId(), List.of()); - } - - public int currentCredits() { - return activeRegistrations.stream() - .mapToInt(ActiveRegistrationSnapshot::credit) - .sum(); - } - - public int totalCreditsAfter() { - return currentCredits() + lesson.subjectCredit(); - } -} diff --git a/src/main/java/com/study/course_registration/domain/registration/RegistrationDecisionSnapshot.java b/src/main/java/com/study/course_registration/domain/registration/RegistrationDecisionSnapshot.java new file mode 100644 index 0000000..9789f20 --- /dev/null +++ b/src/main/java/com/study/course_registration/domain/registration/RegistrationDecisionSnapshot.java @@ -0,0 +1,55 @@ +package com.study.course_registration.domain.registration; + +import java.time.Instant; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +import com.study.course_registration.domain.schedule.ScheduleSlot; + +public record RegistrationDecisionSnapshot( + UserProfile user, + LessonPolicySnapshot lesson, + List activeRegistrations, + Map> schedulesByLessonId, + long enrolledCount, + Instant now) { + + public RegistrationDecisionSnapshot { + Objects.requireNonNull(user, "user"); + Objects.requireNonNull(lesson, "lesson"); + Objects.requireNonNull(activeRegistrations, "activeRegistrations"); + Objects.requireNonNull(schedulesByLessonId, "schedulesByLessonId"); + Objects.requireNonNull(now, "now"); + if (enrolledCount < 0) { + throw RegistrationInvariantViolation.negativeEnrolledCount(); + } + + activeRegistrations = List.copyOf(activeRegistrations); + Map> copiedSchedules = new LinkedHashMap<>(); + schedulesByLessonId.forEach((lessonId, slots) -> copiedSchedules.put( + Objects.requireNonNull(lessonId, "schedule lessonId"), + List.copyOf(Objects.requireNonNull(slots, "schedule slots")))); + schedulesByLessonId = Collections.unmodifiableMap(copiedSchedules); + } + + public List candidateSchedules() { + return schedulesByLessonId.getOrDefault(lesson.id(), List.of()); + } + + public List schedulesOf(ActiveRegistrationSnapshot registration) { + return schedulesByLessonId.getOrDefault(registration.lessonId(), List.of()); + } + + public int currentCredits() { + return activeRegistrations.stream() + .mapToInt(ActiveRegistrationSnapshot::credit) + .sum(); + } + + public int totalCreditsAfter() { + return currentCredits() + lesson.subjectCredit(); + } +} diff --git a/src/main/java/com/study/course_registration/domain/registration/RegistrationInvariant.java b/src/main/java/com/study/course_registration/domain/registration/RegistrationInvariant.java new file mode 100644 index 0000000..810123e --- /dev/null +++ b/src/main/java/com/study/course_registration/domain/registration/RegistrationInvariant.java @@ -0,0 +1,7 @@ +package com.study.course_registration.domain.registration; + +public enum RegistrationInvariant { + NEGATIVE_ENROLLED_COUNT, + MISSING_CANDIDATE_LESSON_SCHEDULE, + MISSING_EXISTING_LESSON_SCHEDULE +} diff --git a/src/main/java/com/study/course_registration/domain/registration/RegistrationInvariantViolation.java b/src/main/java/com/study/course_registration/domain/registration/RegistrationInvariantViolation.java new file mode 100644 index 0000000..3af02a0 --- /dev/null +++ b/src/main/java/com/study/course_registration/domain/registration/RegistrationInvariantViolation.java @@ -0,0 +1,32 @@ +package com.study.course_registration.domain.registration; + +public final class RegistrationInvariantViolation extends RuntimeException { + private final RegistrationInvariant invariant; + + private RegistrationInvariantViolation(RegistrationInvariant invariant, String message) { + super(message); + this.invariant = invariant; + } + + public static RegistrationInvariantViolation negativeEnrolledCount() { + return new RegistrationInvariantViolation( + RegistrationInvariant.NEGATIVE_ENROLLED_COUNT, + "수강 인원 수는 음수일 수 없습니다."); + } + + public static RegistrationInvariantViolation missingCandidateSchedule() { + return new RegistrationInvariantViolation( + RegistrationInvariant.MISSING_CANDIDATE_LESSON_SCHEDULE, + "신청 가능한 강의에 시간표가 없습니다."); + } + + public static RegistrationInvariantViolation missingExistingSchedule() { + return new RegistrationInvariantViolation( + RegistrationInvariant.MISSING_EXISTING_LESSON_SCHEDULE, + "기존 신청 강의에 시간표가 없습니다."); + } + + public RegistrationInvariant invariant() { + return invariant; + } +} diff --git a/src/main/java/com/study/course_registration/domain/registration/RegistrationPolicy.java b/src/main/java/com/study/course_registration/domain/registration/RegistrationPolicy.java index 8ea0687..528c14b 100644 --- a/src/main/java/com/study/course_registration/domain/registration/RegistrationPolicy.java +++ b/src/main/java/com/study/course_registration/domain/registration/RegistrationPolicy.java @@ -1,43 +1,44 @@ package com.study.course_registration.domain.registration; -import java.util.List; - import com.study.course_registration.domain.registration.rule.AlreadyRegisteredRule; import com.study.course_registration.domain.registration.rule.CapacityRule; import com.study.course_registration.domain.registration.rule.CreditLimitRule; import com.study.course_registration.domain.registration.rule.DuplicateSubjectRule; -import com.study.course_registration.domain.registration.rule.GradeEligibilityRule; -import com.study.course_registration.domain.registration.rule.RegistrationPeriodRule; -import com.study.course_registration.domain.registration.rule.RoleEligibilityRule; import com.study.course_registration.domain.registration.rule.ScheduleAvailabilityRule; import com.study.course_registration.domain.registration.rule.ScheduleConflictRule; public final class RegistrationPolicy { - private final List orderedRules; + private final AlreadyRegisteredRule alreadyRegistered; + private final DuplicateSubjectRule duplicateSubject; + private final ScheduleAvailabilityRule scheduleAvailability; + private final ScheduleConflictRule scheduleConflict; + private final CreditLimitRule creditLimit; + private final CapacityRule capacity; public RegistrationPolicy( - RegistrationPeriodRule registrationPeriodRule, - GradeEligibilityRule gradeEligibilityRule, - RoleEligibilityRule roleEligibilityRule, - AlreadyRegisteredRule alreadyRegisteredRule, - DuplicateSubjectRule duplicateSubjectRule, - ScheduleAvailabilityRule scheduleAvailabilityRule, - ScheduleConflictRule scheduleConflictRule, - CreditLimitRule creditLimitRule, - CapacityRule capacityRule) { - this.orderedRules = List.of( - registrationPeriodRule, - gradeEligibilityRule, - roleEligibilityRule, - alreadyRegisteredRule, - duplicateSubjectRule, - scheduleAvailabilityRule, - scheduleConflictRule, - creditLimitRule, - capacityRule); + AlreadyRegisteredRule alreadyRegistered, + DuplicateSubjectRule duplicateSubject, + ScheduleAvailabilityRule scheduleAvailability, + ScheduleConflictRule scheduleConflict, + CreditLimitRule creditLimit, + CapacityRule capacity) { + this.alreadyRegistered = alreadyRegistered; + this.duplicateSubject = duplicateSubject; + this.scheduleAvailability = scheduleAvailability; + this.scheduleConflict = scheduleConflict; + this.creditLimit = creditLimit; + this.capacity = capacity; } - public void validate(RegistrationContext context) { - orderedRules.forEach(rule -> rule.validate(context)); + public void validate(RegistrationDecisionSnapshot snapshot) { + snapshot.lesson().verifyRegistrationWindow(snapshot.now()); + snapshot.lesson().verifyStudentEligibility(snapshot.user()); + + alreadyRegistered.verify(snapshot); + duplicateSubject.verify(snapshot); + scheduleAvailability.verify(snapshot); + scheduleConflict.verify(snapshot); + creditLimit.verify(snapshot); + capacity.verify(snapshot); } } diff --git a/src/main/java/com/study/course_registration/domain/registration/RegistrationRejection.java b/src/main/java/com/study/course_registration/domain/registration/RegistrationRejection.java new file mode 100644 index 0000000..b937a1b --- /dev/null +++ b/src/main/java/com/study/course_registration/domain/registration/RegistrationRejection.java @@ -0,0 +1,70 @@ +package com.study.course_registration.domain.registration; + +import java.time.DayOfWeek; +import java.time.LocalTime; + +import com.study.course_registration.enums.UserRole; + +public final class RegistrationRejection extends RuntimeException { + private final RegistrationRejectionCode code; + + private RegistrationRejection(RegistrationRejectionCode code, String message) { + super(message); + this.code = code; + } + + public static RegistrationRejection registrationPeriodClosed() { + return new RegistrationRejection( + RegistrationRejectionCode.REGISTRATION_PERIOD_CLOSED, + "수강신청 기간이 아닙니다."); + } + + public static RegistrationRejection notEligibleGrade(long currentGrade, long minGrade) { + return new RegistrationRejection( + RegistrationRejectionCode.NOT_ELIGIBLE_GRADE, + "수강 가능한 학년이 아닙니다. (현재 " + currentGrade + "학년, 최소 " + minGrade + "학년)"); + } + + public static RegistrationRejection notEligibleRole(UserRole requiredRole) { + return new RegistrationRejection( + RegistrationRejectionCode.NOT_ELIGIBLE_ROLE, + "수강 가능한 역할이 아닙니다. (필요 역할: " + requiredRole + ")"); + } + + public static RegistrationRejection alreadyRegistered() { + return new RegistrationRejection( + RegistrationRejectionCode.ALREADY_REGISTERED, + "이미 신청한 강의입니다."); + } + + public static RegistrationRejection duplicateSubject() { + return new RegistrationRejection( + RegistrationRejectionCode.DUPLICATE_SUBJECT, + "같은 과목의 다른 분반을 이미 신청했습니다."); + } + + public static RegistrationRejection scheduleConflict( + DayOfWeek dayOfWeek, + LocalTime startTime, + LocalTime endTime) { + return new RegistrationRejection( + RegistrationRejectionCode.SCHEDULE_CONFLICT, + "기존 수업과 시간이 겹칩니다. (" + dayOfWeek + " " + startTime + "-" + endTime + ")"); + } + + public static RegistrationRejection creditLimitExceeded(int current, int requested, int max) { + return new RegistrationRejection( + RegistrationRejectionCode.CREDIT_LIMIT_EXCEEDED, + "신청 학점이 상한을 넘습니다. (" + current + " + " + requested + " > " + max + ")"); + } + + public static RegistrationRejection capacityExceeded(long enrolled, int capacity) { + return new RegistrationRejection( + RegistrationRejectionCode.CAPACITY_EXCEEDED, + "정원이 가득 찼습니다. (" + enrolled + "/" + capacity + ")"); + } + + public RegistrationRejectionCode code() { + return code; + } +} diff --git a/src/main/java/com/study/course_registration/domain/registration/RegistrationRejectionCode.java b/src/main/java/com/study/course_registration/domain/registration/RegistrationRejectionCode.java new file mode 100644 index 0000000..ce23821 --- /dev/null +++ b/src/main/java/com/study/course_registration/domain/registration/RegistrationRejectionCode.java @@ -0,0 +1,12 @@ +package com.study.course_registration.domain.registration; + +public enum RegistrationRejectionCode { + REGISTRATION_PERIOD_CLOSED, + NOT_ELIGIBLE_GRADE, + NOT_ELIGIBLE_ROLE, + ALREADY_REGISTERED, + DUPLICATE_SUBJECT, + SCHEDULE_CONFLICT, + CREDIT_LIMIT_EXCEEDED, + CAPACITY_EXCEEDED +} diff --git a/src/main/java/com/study/course_registration/domain/registration/RegistrationRule.java b/src/main/java/com/study/course_registration/domain/registration/RegistrationRule.java deleted file mode 100644 index e4f2028..0000000 --- a/src/main/java/com/study/course_registration/domain/registration/RegistrationRule.java +++ /dev/null @@ -1,5 +0,0 @@ -package com.study.course_registration.domain.registration; - -public interface RegistrationRule { - void validate(RegistrationContext context); -} diff --git a/src/main/java/com/study/course_registration/domain/registration/RegistrationWindowGuard.java b/src/main/java/com/study/course_registration/domain/registration/RegistrationWindowGuard.java index adbb93f..c91b6fd 100644 --- a/src/main/java/com/study/course_registration/domain/registration/RegistrationWindowGuard.java +++ b/src/main/java/com/study/course_registration/domain/registration/RegistrationWindowGuard.java @@ -2,13 +2,8 @@ package com.study.course_registration.domain.registration; import java.time.Instant; -import com.study.course_registration.failure.BusinessRejection; - public final class RegistrationWindowGuard { public void verify(LessonPolicySnapshot lesson, Instant now) { - if (now.isBefore(lesson.registrationStartAt()) - || now.isAfter(lesson.registrationEndAt())) { - throw BusinessRejection.registrationPeriodClosed(); - } + lesson.verifyRegistrationWindow(now); } } diff --git a/src/main/java/com/study/course_registration/domain/registration/UserProfile.java b/src/main/java/com/study/course_registration/domain/registration/UserProfile.java index 01e1fc6..baf5148 100644 --- a/src/main/java/com/study/course_registration/domain/registration/UserProfile.java +++ b/src/main/java/com/study/course_registration/domain/registration/UserProfile.java @@ -1,9 +1,19 @@ package com.study.course_registration.domain.registration; +import java.util.Objects; + import com.study.course_registration.enums.UserRole; public record UserProfile( String id, long grade, UserRole role) { + + public UserProfile { + Objects.requireNonNull(id, "id"); + Objects.requireNonNull(role, "role"); + if (grade < 1) { + throw new IllegalArgumentException("grade must be at least 1"); + } + } } diff --git a/src/main/java/com/study/course_registration/domain/registration/rule/AlreadyRegisteredRule.java b/src/main/java/com/study/course_registration/domain/registration/rule/AlreadyRegisteredRule.java index c23cbfb..d367019 100644 --- a/src/main/java/com/study/course_registration/domain/registration/rule/AlreadyRegisteredRule.java +++ b/src/main/java/com/study/course_registration/domain/registration/rule/AlreadyRegisteredRule.java @@ -1,16 +1,14 @@ package com.study.course_registration.domain.registration.rule; -import com.study.course_registration.domain.registration.RegistrationContext; -import com.study.course_registration.domain.registration.RegistrationRule; -import com.study.course_registration.failure.BusinessRejection; +import com.study.course_registration.domain.registration.RegistrationDecisionSnapshot; +import com.study.course_registration.domain.registration.RegistrationRejection; -public final class AlreadyRegisteredRule implements RegistrationRule { - @Override - public void validate(RegistrationContext context) { - boolean duplicate = context.activeRegistrations().stream() - .anyMatch(registration -> registration.lessonId().equals(context.lesson().id())); +public final class AlreadyRegisteredRule { + public void verify(RegistrationDecisionSnapshot snapshot) { + boolean duplicate = snapshot.activeRegistrations().stream() + .anyMatch(registration -> registration.lessonId().equals(snapshot.lesson().id())); if (duplicate) { - throw BusinessRejection.alreadyRegistered(); + throw RegistrationRejection.alreadyRegistered(); } } } diff --git a/src/main/java/com/study/course_registration/domain/registration/rule/CapacityRule.java b/src/main/java/com/study/course_registration/domain/registration/rule/CapacityRule.java index 3b4cd24..320a49a 100644 --- a/src/main/java/com/study/course_registration/domain/registration/rule/CapacityRule.java +++ b/src/main/java/com/study/course_registration/domain/registration/rule/CapacityRule.java @@ -1,16 +1,14 @@ package com.study.course_registration.domain.registration.rule; -import com.study.course_registration.domain.registration.RegistrationContext; -import com.study.course_registration.domain.registration.RegistrationRule; -import com.study.course_registration.failure.BusinessRejection; +import com.study.course_registration.domain.registration.RegistrationDecisionSnapshot; +import com.study.course_registration.domain.registration.RegistrationRejection; -public final class CapacityRule implements RegistrationRule { - @Override - public void validate(RegistrationContext context) { - if (context.enrolledCount() >= context.lesson().capacity()) { - throw BusinessRejection.capacityExceeded( - context.enrolledCount(), - context.lesson().capacity()); +public final class CapacityRule { + public void verify(RegistrationDecisionSnapshot snapshot) { + if (snapshot.enrolledCount() >= snapshot.lesson().capacity()) { + throw RegistrationRejection.capacityExceeded( + snapshot.enrolledCount(), + snapshot.lesson().capacity()); } } } diff --git a/src/main/java/com/study/course_registration/domain/registration/rule/CreditLimitRule.java b/src/main/java/com/study/course_registration/domain/registration/rule/CreditLimitRule.java index ddd98a6..7e5e512 100644 --- a/src/main/java/com/study/course_registration/domain/registration/rule/CreditLimitRule.java +++ b/src/main/java/com/study/course_registration/domain/registration/rule/CreditLimitRule.java @@ -1,17 +1,15 @@ package com.study.course_registration.domain.registration.rule; -import com.study.course_registration.domain.registration.RegistrationContext; -import com.study.course_registration.domain.registration.RegistrationRule; -import com.study.course_registration.failure.BusinessRejection; +import com.study.course_registration.domain.registration.RegistrationDecisionSnapshot; +import com.study.course_registration.domain.registration.RegistrationRejection; -public final class CreditLimitRule implements RegistrationRule { - @Override - public void validate(RegistrationContext context) { - int current = context.currentCredits(); - int requested = context.lesson().subjectCredit(); - int max = context.lesson().maxCredits(); +public final class CreditLimitRule { + public void verify(RegistrationDecisionSnapshot snapshot) { + int current = snapshot.currentCredits(); + int requested = snapshot.lesson().subjectCredit(); + int max = snapshot.lesson().maxCredits(); if (current + requested > max) { - throw BusinessRejection.creditLimitExceeded(current, requested, max); + throw RegistrationRejection.creditLimitExceeded(current, requested, max); } } } diff --git a/src/main/java/com/study/course_registration/domain/registration/rule/DuplicateSubjectRule.java b/src/main/java/com/study/course_registration/domain/registration/rule/DuplicateSubjectRule.java index a9147a9..422577b 100644 --- a/src/main/java/com/study/course_registration/domain/registration/rule/DuplicateSubjectRule.java +++ b/src/main/java/com/study/course_registration/domain/registration/rule/DuplicateSubjectRule.java @@ -1,16 +1,14 @@ package com.study.course_registration.domain.registration.rule; -import com.study.course_registration.domain.registration.RegistrationContext; -import com.study.course_registration.domain.registration.RegistrationRule; -import com.study.course_registration.failure.BusinessRejection; +import com.study.course_registration.domain.registration.RegistrationDecisionSnapshot; +import com.study.course_registration.domain.registration.RegistrationRejection; -public final class DuplicateSubjectRule implements RegistrationRule { - @Override - public void validate(RegistrationContext context) { - boolean duplicate = context.activeRegistrations().stream() - .anyMatch(registration -> registration.subjectId().equals(context.lesson().subjectId())); +public final class DuplicateSubjectRule { + public void verify(RegistrationDecisionSnapshot snapshot) { + boolean duplicate = snapshot.activeRegistrations().stream() + .anyMatch(registration -> registration.subjectId().equals(snapshot.lesson().subjectId())); if (duplicate) { - throw BusinessRejection.duplicateSubject(); + throw RegistrationRejection.duplicateSubject(); } } } diff --git a/src/main/java/com/study/course_registration/domain/registration/rule/GradeEligibilityRule.java b/src/main/java/com/study/course_registration/domain/registration/rule/GradeEligibilityRule.java deleted file mode 100644 index 7833c01..0000000 --- a/src/main/java/com/study/course_registration/domain/registration/rule/GradeEligibilityRule.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.study.course_registration.domain.registration.rule; - -import com.study.course_registration.domain.registration.RegistrationContext; -import com.study.course_registration.domain.registration.RegistrationRule; -import com.study.course_registration.failure.BusinessRejection; - -public final class GradeEligibilityRule implements RegistrationRule { - @Override - public void validate(RegistrationContext context) { - Long minGrade = context.lesson().minGrade(); - if (minGrade != null && context.user().grade() < minGrade) { - throw BusinessRejection.notEligibleGrade(context.user().grade(), minGrade); - } - } -} diff --git a/src/main/java/com/study/course_registration/domain/registration/rule/RegistrationPeriodRule.java b/src/main/java/com/study/course_registration/domain/registration/rule/RegistrationPeriodRule.java deleted file mode 100644 index 1dbb3f4..0000000 --- a/src/main/java/com/study/course_registration/domain/registration/rule/RegistrationPeriodRule.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.study.course_registration.domain.registration.rule; - -import com.study.course_registration.domain.registration.RegistrationContext; -import com.study.course_registration.domain.registration.RegistrationRule; -import com.study.course_registration.failure.BusinessRejection; - -public final class RegistrationPeriodRule implements RegistrationRule { - @Override - public void validate(RegistrationContext context) { - if (context.now().isBefore(context.lesson().registrationStartAt()) - || context.now().isAfter(context.lesson().registrationEndAt())) { - throw BusinessRejection.registrationPeriodClosed(); - } - } -} diff --git a/src/main/java/com/study/course_registration/domain/registration/rule/RoleEligibilityRule.java b/src/main/java/com/study/course_registration/domain/registration/rule/RoleEligibilityRule.java deleted file mode 100644 index 5790e84..0000000 --- a/src/main/java/com/study/course_registration/domain/registration/rule/RoleEligibilityRule.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.study.course_registration.domain.registration.rule; - -import com.study.course_registration.domain.registration.RegistrationContext; -import com.study.course_registration.domain.registration.RegistrationRule; -import com.study.course_registration.failure.BusinessRejection; - -public final class RoleEligibilityRule implements RegistrationRule { - @Override - public void validate(RegistrationContext context) { - if (context.lesson().allowedRole() != null - && context.user().role() != context.lesson().allowedRole()) { - throw BusinessRejection.notEligibleRole(context.lesson().allowedRole()); - } - } -} diff --git a/src/main/java/com/study/course_registration/domain/registration/rule/ScheduleAvailabilityRule.java b/src/main/java/com/study/course_registration/domain/registration/rule/ScheduleAvailabilityRule.java index 533d7f1..125443d 100644 --- a/src/main/java/com/study/course_registration/domain/registration/rule/ScheduleAvailabilityRule.java +++ b/src/main/java/com/study/course_registration/domain/registration/rule/ScheduleAvailabilityRule.java @@ -1,18 +1,16 @@ package com.study.course_registration.domain.registration.rule; -import com.study.course_registration.domain.registration.RegistrationContext; -import com.study.course_registration.domain.registration.RegistrationRule; -import com.study.course_registration.failure.SystemInvariantViolation; +import com.study.course_registration.domain.registration.RegistrationDecisionSnapshot; +import com.study.course_registration.domain.registration.RegistrationInvariantViolation; -public final class ScheduleAvailabilityRule implements RegistrationRule { - @Override - public void validate(RegistrationContext context) { - if (context.candidateSchedules().isEmpty()) { - throw SystemInvariantViolation.missingCandidateSchedule(); +public final class ScheduleAvailabilityRule { + public void verify(RegistrationDecisionSnapshot snapshot) { + if (snapshot.candidateSchedules().isEmpty()) { + throw RegistrationInvariantViolation.missingCandidateSchedule(); } - context.activeRegistrations().forEach(registration -> { - if (context.schedulesOf(registration).isEmpty()) { - throw SystemInvariantViolation.missingExistingSchedule(); + snapshot.activeRegistrations().forEach(registration -> { + if (snapshot.schedulesOf(registration).isEmpty()) { + throw RegistrationInvariantViolation.missingExistingSchedule(); } }); } diff --git a/src/main/java/com/study/course_registration/domain/registration/rule/ScheduleConflictRule.java b/src/main/java/com/study/course_registration/domain/registration/rule/ScheduleConflictRule.java index 1b9ce68..818f59d 100644 --- a/src/main/java/com/study/course_registration/domain/registration/rule/ScheduleConflictRule.java +++ b/src/main/java/com/study/course_registration/domain/registration/rule/ScheduleConflictRule.java @@ -1,26 +1,24 @@ package com.study.course_registration.domain.registration.rule; import com.study.course_registration.domain.registration.ActiveRegistrationSnapshot; -import com.study.course_registration.domain.registration.RegistrationContext; -import com.study.course_registration.domain.registration.RegistrationRule; +import com.study.course_registration.domain.registration.RegistrationDecisionSnapshot; +import com.study.course_registration.domain.registration.RegistrationRejection; import com.study.course_registration.domain.schedule.ScheduleConflictChecker; import com.study.course_registration.domain.schedule.ScheduleSlot; -import com.study.course_registration.failure.BusinessRejection; -public final class ScheduleConflictRule implements RegistrationRule { +public final class ScheduleConflictRule { private final ScheduleConflictChecker conflictChecker; public ScheduleConflictRule(ScheduleConflictChecker conflictChecker) { this.conflictChecker = conflictChecker; } - @Override - public void validate(RegistrationContext context) { - for (ActiveRegistrationSnapshot registration : context.activeRegistrations()) { - for (ScheduleSlot candidate : context.candidateSchedules()) { - for (ScheduleSlot existing : context.schedulesOf(registration)) { + public void verify(RegistrationDecisionSnapshot snapshot) { + for (ActiveRegistrationSnapshot registration : snapshot.activeRegistrations()) { + for (ScheduleSlot candidate : snapshot.candidateSchedules()) { + for (ScheduleSlot existing : snapshot.schedulesOf(registration)) { if (conflictChecker.overlaps(candidate, existing)) { - throw BusinessRejection.scheduleConflict( + throw RegistrationRejection.scheduleConflict( candidate.dayOfWeek(), candidate.startTime(), candidate.endTime()); diff --git a/src/main/java/com/study/course_registration/entity/UserLesson.java b/src/main/java/com/study/course_registration/entity/UserLesson.java index e4b6f8d..0b1300e 100644 --- a/src/main/java/com/study/course_registration/entity/UserLesson.java +++ b/src/main/java/com/study/course_registration/entity/UserLesson.java @@ -41,10 +41,9 @@ public class UserLesson extends BaseCreateEntity { } public void cancel(Instant canceledAt) { - if (this.canceledAt != null) { - throw new IllegalStateException("registration is already canceled"); + if (this.canceledAt == null) { + this.canceledAt = Objects.requireNonNull(canceledAt, "canceledAt"); } - this.canceledAt = Objects.requireNonNull(canceledAt, "canceledAt"); } public boolean isCanceled() { diff --git a/src/main/java/com/study/course_registration/enums/RegistrationErrorCode.java b/src/main/java/com/study/course_registration/enums/RegistrationErrorCode.java index 828452a..7e211b7 100644 --- a/src/main/java/com/study/course_registration/enums/RegistrationErrorCode.java +++ b/src/main/java/com/study/course_registration/enums/RegistrationErrorCode.java @@ -17,5 +17,7 @@ public enum RegistrationErrorCode { CAPACITY_EXCEEDED, IDEMPOTENCY_KEY_REUSED, LOCK_TIMEOUT, + DB_POOL_EXHAUSTED, + DB_UNAVAILABLE, INTERNAL_SERVER_ERROR } diff --git a/src/main/java/com/study/course_registration/failure/BusinessRejection.java b/src/main/java/com/study/course_registration/failure/BusinessRejection.java deleted file mode 100644 index 147d0dc..0000000 --- a/src/main/java/com/study/course_registration/failure/BusinessRejection.java +++ /dev/null @@ -1,70 +0,0 @@ -package com.study.course_registration.failure; - -import java.time.DayOfWeek; -import java.time.LocalTime; - -import com.study.course_registration.enums.RegistrationErrorCode; -import com.study.course_registration.enums.UserRole; - -public final class BusinessRejection extends ApplicationFailure { - private BusinessRejection(RegistrationErrorCode code, String message) { - super(code, message); - } - - public static BusinessRejection registrationPeriodClosed() { - return new BusinessRejection( - RegistrationErrorCode.REGISTRATION_PERIOD_CLOSED, - "수강신청 기간이 아닙니다."); - } - - public static BusinessRejection notEligibleGrade(long currentGrade, long minGrade) { - return new BusinessRejection( - RegistrationErrorCode.NOT_ELIGIBLE_GRADE, - "수강 가능한 학년이 아닙니다. (현재 " + currentGrade + "학년, 최소 " + minGrade + "학년)"); - } - - public static BusinessRejection notEligibleRole(UserRole requiredRole) { - return new BusinessRejection( - RegistrationErrorCode.NOT_ELIGIBLE_ROLE, - "수강 가능한 역할이 아닙니다. (필요 역할: " + requiredRole + ")"); - } - - public static BusinessRejection alreadyRegistered() { - return new BusinessRejection( - RegistrationErrorCode.ALREADY_REGISTERED, - "이미 신청한 강의입니다."); - } - - public static BusinessRejection duplicateSubject() { - return new BusinessRejection( - RegistrationErrorCode.DUPLICATE_SUBJECT, - "같은 과목의 다른 분반을 이미 신청했습니다."); - } - - public static BusinessRejection scheduleConflict( - DayOfWeek dayOfWeek, - LocalTime startTime, - LocalTime endTime) { - return new BusinessRejection( - RegistrationErrorCode.SCHEDULE_CONFLICT, - "기존 수업과 시간이 겹칩니다. (" + dayOfWeek + " " + startTime + "-" + endTime + ")"); - } - - public static BusinessRejection creditLimitExceeded(int current, int requested, int max) { - return new BusinessRejection( - RegistrationErrorCode.CREDIT_LIMIT_EXCEEDED, - "신청 학점이 상한을 넘습니다. (" + current + " + " + requested + " > " + max + ")"); - } - - public static BusinessRejection capacityExceeded(long enrolled, int capacity) { - return new BusinessRejection( - RegistrationErrorCode.CAPACITY_EXCEEDED, - "정원이 가득 찼습니다. (" + enrolled + "/" + capacity + ")"); - } - - public static BusinessRejection idempotencyKeyReused() { - return new BusinessRejection( - RegistrationErrorCode.IDEMPOTENCY_KEY_REUSED, - "동일한 Idempotency-Key를 다른 강의에 사용할 수 없습니다."); - } -} diff --git a/src/main/java/com/study/course_registration/failure/InfrastructureFailureReason.java b/src/main/java/com/study/course_registration/failure/InfrastructureFailureReason.java new file mode 100644 index 0000000..b6737a5 --- /dev/null +++ b/src/main/java/com/study/course_registration/failure/InfrastructureFailureReason.java @@ -0,0 +1,7 @@ +package com.study.course_registration.failure; + +public enum InfrastructureFailureReason { + LOCK_CONTENTION, + DB_POOL_EXHAUSTED, + DB_UNAVAILABLE +} diff --git a/src/main/java/com/study/course_registration/failure/RetryableInfrastructureFailure.java b/src/main/java/com/study/course_registration/failure/RetryableInfrastructureFailure.java index 2fdd9ce..4545110 100644 --- a/src/main/java/com/study/course_registration/failure/RetryableInfrastructureFailure.java +++ b/src/main/java/com/study/course_registration/failure/RetryableInfrastructureFailure.java @@ -3,13 +3,42 @@ package com.study.course_registration.failure; import com.study.course_registration.enums.RegistrationErrorCode; public final class RetryableInfrastructureFailure extends KnownFailure { - private RetryableInfrastructureFailure(String message, Throwable cause) { - super(RegistrationErrorCode.LOCK_TIMEOUT, message, cause); + private final InfrastructureFailureReason reason; + + private RetryableInfrastructureFailure( + RegistrationErrorCode errorCode, + InfrastructureFailureReason reason, + String message, + Throwable cause) { + super(errorCode, message, cause); + this.reason = reason; } public static RetryableInfrastructureFailure lockTimeout(Throwable cause) { return new RetryableInfrastructureFailure( + RegistrationErrorCode.LOCK_TIMEOUT, + InfrastructureFailureReason.LOCK_CONTENTION, "다른 요청이 처리 중입니다. 잠시 후 다시 시도해 주세요.", cause); } + + public static RetryableInfrastructureFailure dbPoolExhausted(Throwable cause) { + return new RetryableInfrastructureFailure( + RegistrationErrorCode.DB_POOL_EXHAUSTED, + InfrastructureFailureReason.DB_POOL_EXHAUSTED, + "데이터베이스 연결이 혼잡합니다. 잠시 후 다시 시도해 주세요.", + cause); + } + + public static RetryableInfrastructureFailure dbUnavailable(Throwable cause) { + return new RetryableInfrastructureFailure( + RegistrationErrorCode.DB_UNAVAILABLE, + InfrastructureFailureReason.DB_UNAVAILABLE, + "데이터베이스에 일시적으로 연결할 수 없습니다. 잠시 후 다시 시도해 주세요.", + cause); + } + + public InfrastructureFailureReason reason() { + return reason; + } } diff --git a/src/main/java/com/study/course_registration/infrastructure/persistence/JpaCancellationContextLoader.java b/src/main/java/com/study/course_registration/infrastructure/persistence/JpaCancellationContextLoader.java index 0bad470..82761a3 100644 --- a/src/main/java/com/study/course_registration/infrastructure/persistence/JpaCancellationContextLoader.java +++ b/src/main/java/com/study/course_registration/infrastructure/persistence/JpaCancellationContextLoader.java @@ -3,6 +3,7 @@ package com.study.course_registration.infrastructure.persistence; import org.springframework.dao.PessimisticLockingFailureException; import org.springframework.stereotype.Component; +import com.study.course_registration.application.registration.model.CancellationTarget; import com.study.course_registration.application.registration.port.CancellationContextLoader; import com.study.course_registration.domain.registration.CancellationContext; import com.study.course_registration.entity.Lesson; @@ -32,20 +33,23 @@ public class JpaCancellationContextLoader implements CancellationContextLoader { } @Override - public CancellationContext load(String registrationId) { + public CancellationTarget findTarget(String registrationId) { UserLessonRepository.RegistrationTarget target = registrations.findTargetById(registrationId) .orElseThrow(ResourceNotFound::registration); + return new CancellationTarget(registrationId, target.getUserId(), target.getLessonId()); + } + @Override + public CancellationContext lock(CancellationTarget target) { try { - users.findByIdForUpdate(target.getUserId()).orElseThrow(ResourceNotFound::user); - Lesson lesson = lessons.findByIdForUpdate(target.getLessonId()) + users.findByIdForUpdate(target.ownerUserId()).orElseThrow(ResourceNotFound::user); + Lesson lesson = lessons.findByIdForUpdate(target.lessonId()) .orElseThrow(ResourceNotFound::lesson); - UserLesson registration = registrations.findById(registrationId) + UserLesson registration = registrations.findById(target.registrationId()) .orElseThrow(ResourceNotFound::registration); return new CancellationContext( - target.getUserId(), registration.getId(), JpaSnapshotMapper.lessonPolicy(lesson), registration.isCanceled()); diff --git a/src/main/java/com/study/course_registration/infrastructure/persistence/JpaIdempotencyAdapter.java b/src/main/java/com/study/course_registration/infrastructure/persistence/JpaIdempotencyAdapter.java index c966762..095b301 100644 --- a/src/main/java/com/study/course_registration/infrastructure/persistence/JpaIdempotencyAdapter.java +++ b/src/main/java/com/study/course_registration/infrastructure/persistence/JpaIdempotencyAdapter.java @@ -1,16 +1,20 @@ package com.study.course_registration.infrastructure.persistence; import java.time.Instant; +import java.util.List; import java.util.Optional; +import org.springframework.data.domain.PageRequest; import org.springframework.stereotype.Component; -import com.study.course_registration.application.idempotency.port.IdempotencyPort; +import com.study.course_registration.application.registration.idempotency.model.IdempotencyReplay; +import com.study.course_registration.application.registration.idempotency.model.IdempotencySaveCommand; +import com.study.course_registration.application.registration.idempotency.port.IdempotencyPort; import com.study.course_registration.entity.Lesson; -import com.study.course_registration.entity.RegistrationIdempotency; import com.study.course_registration.entity.User; import com.study.course_registration.entity.UserLesson; import com.study.course_registration.failure.ResourceNotFound; +import com.study.course_registration.infrastructure.persistence.idempotency.RegistrationIdempotencyEntity; import com.study.course_registration.infrastructure.persistence.repository.LessonRepository; import com.study.course_registration.infrastructure.persistence.repository.RegistrationIdempotencyRepository; import com.study.course_registration.infrastructure.persistence.repository.UserLessonRepository; @@ -35,16 +39,16 @@ public class JpaIdempotencyAdapter implements IdempotencyPort { } @Override - public Optional findActive(String userId, String key, Instant now) { + public Optional findActive(String userId, String key, Instant now) { return repository.findByUser_IdAndIdempotencyKeyAndExpiresAtAfter(userId, key, now) - .map(stored -> new ReplayRecord( + .map(stored -> new IdempotencyReplay( stored.getRegistration().getId(), stored.getUser().getId(), stored.getLesson().getId(), - stored.getLesson().getName(), - stored.getLesson().getSubject().getCode(), - stored.getLesson().getSubject().getCredit(), - stored.getRegistration().getCreatedAt(), + stored.getLessonName(), + stored.getSubjectCode(), + stored.getCredit(), + stored.getRegisteredAt(), stored.getTotalCredits())); } @@ -54,22 +58,31 @@ public class JpaIdempotencyAdapter implements IdempotencyPort { } @Override - public void deleteExpired(Instant now) { - repository.deleteExpired(now); + public int deleteExpiredBatch(Instant now, int batchSize) { + List ids = repository.findExpiredIds(now, PageRequest.of(0, batchSize)); + if (ids.isEmpty()) { + return 0; + } + repository.deleteAllByIdInBatch(ids); + return ids.size(); } @Override - public void save(SaveCommand command) { + public void save(IdempotencySaveCommand command) { User user = users.findById(command.userId()).orElseThrow(ResourceNotFound::user); Lesson lesson = lessons.findById(command.lessonId()).orElseThrow(ResourceNotFound::lesson); UserLesson registration = registrations.findById(command.registrationId()) .orElseThrow(ResourceNotFound::registration); - repository.saveAndFlush(new RegistrationIdempotency( + repository.saveAndFlush(new RegistrationIdempotencyEntity( user, lesson, registration, command.key(), + command.lessonName(), + command.subjectCode(), + command.credit(), + command.registeredAt(), command.totalCredits(), command.expiresAt())); } diff --git a/src/main/java/com/study/course_registration/infrastructure/persistence/JpaLessonQueryAdapter.java b/src/main/java/com/study/course_registration/infrastructure/persistence/JpaLessonQueryAdapter.java index 1e0f237..deabf07 100644 --- a/src/main/java/com/study/course_registration/infrastructure/persistence/JpaLessonQueryAdapter.java +++ b/src/main/java/com/study/course_registration/infrastructure/persistence/JpaLessonQueryAdapter.java @@ -12,6 +12,9 @@ import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Sort; import org.springframework.stereotype.Component; +import com.study.course_registration.application.lesson.model.LessonDetailView; +import com.study.course_registration.application.lesson.model.LessonListView; +import com.study.course_registration.application.lesson.model.LessonPage; import com.study.course_registration.application.lesson.port.LessonQueryPort; import com.study.course_registration.domain.schedule.ScheduleSlot; import com.study.course_registration.entity.Lesson; diff --git a/src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationDecisionContextLoader.java b/src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationDecisionSnapshotLoader.java similarity index 90% rename from src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationDecisionContextLoader.java rename to src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationDecisionSnapshotLoader.java index 2804242..b702775 100644 --- a/src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationDecisionContextLoader.java +++ b/src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationDecisionSnapshotLoader.java @@ -10,10 +10,10 @@ import java.util.stream.Collectors; import org.springframework.stereotype.Component; -import com.study.course_registration.application.registration.port.RegistrationDecisionContextLoader; +import com.study.course_registration.application.registration.port.RegistrationDecisionSnapshotLoader; import com.study.course_registration.domain.registration.ActiveRegistrationSnapshot; import com.study.course_registration.domain.registration.LessonPolicySnapshot; -import com.study.course_registration.domain.registration.RegistrationContext; +import com.study.course_registration.domain.registration.RegistrationDecisionSnapshot; import com.study.course_registration.domain.registration.RegistrationExecutionScope; import com.study.course_registration.domain.registration.UserProfile; import com.study.course_registration.domain.schedule.ScheduleSlot; @@ -27,13 +27,13 @@ import com.study.course_registration.infrastructure.persistence.repository.UserL import com.study.course_registration.infrastructure.persistence.repository.UserRepository; @Component -public class JpaRegistrationDecisionContextLoader implements RegistrationDecisionContextLoader { +public class JpaRegistrationDecisionSnapshotLoader implements RegistrationDecisionSnapshotLoader { private final UserRepository users; private final LessonRepository lessons; private final UserLessonRepository registrations; private final LessonScheduleRepository schedules; - public JpaRegistrationDecisionContextLoader( + public JpaRegistrationDecisionSnapshotLoader( UserRepository users, LessonRepository lessons, UserLessonRepository registrations, @@ -45,7 +45,7 @@ public class JpaRegistrationDecisionContextLoader implements RegistrationDecisio } @Override - public RegistrationContext load(RegistrationExecutionScope scope, Instant now) { + public RegistrationDecisionSnapshot load(RegistrationExecutionScope scope, Instant now) { User userEntity = users.findById(scope.userId()).orElseThrow(ResourceNotFound::user); Lesson lessonEntity = lessons.findDetailedById(scope.lessonId()).orElseThrow(ResourceNotFound::lesson); @@ -73,7 +73,7 @@ public class JpaRegistrationDecisionContextLoader implements RegistrationDecisio long enrolled = registrations.countByLesson_IdAndCanceledAtIsNull(lesson.id()); - return new RegistrationContext( + return new RegistrationDecisionSnapshot( user, lesson, active, diff --git a/src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationExecutionScopeLoader.java b/src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationExecutionScopeLoader.java index 33efd64..2f75a89 100644 --- a/src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationExecutionScopeLoader.java +++ b/src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationExecutionScopeLoader.java @@ -29,10 +29,18 @@ public class JpaRegistrationExecutionScopeLoader implements RegistrationExecutio public RegistrationExecutionScope open(String userId, String lessonId) { try { users.findByIdForUpdate(userId).orElseThrow(ResourceNotFound::user); - lessons.findByIdForUpdate(lessonId).orElseThrow(ResourceNotFound::lesson); return new RegistrationExecutionScope(userId, lessonId); } catch (PessimisticLockingFailureException | LockTimeoutException | PessimisticLockException exception) { throw RetryableInfrastructureFailure.lockTimeout(exception); } } + + @Override + public void lockLesson(RegistrationExecutionScope scope) { + try { + lessons.findByIdForUpdate(scope.lessonId()).orElseThrow(ResourceNotFound::lesson); + } catch (PessimisticLockingFailureException | LockTimeoutException | PessimisticLockException exception) { + throw RetryableInfrastructureFailure.lockTimeout(exception); + } + } } diff --git a/src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationPersistenceAdapter.java b/src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationPersistenceAdapter.java index 45ada28..c96d84d 100644 --- a/src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationPersistenceAdapter.java +++ b/src/main/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationPersistenceAdapter.java @@ -8,6 +8,8 @@ import java.util.stream.Collectors; import org.springframework.stereotype.Component; +import com.study.course_registration.application.registration.model.ActiveRegistrationView; +import com.study.course_registration.application.registration.model.RegistrationRecord; import com.study.course_registration.application.registration.port.RegistrationReader; import com.study.course_registration.application.registration.port.RegistrationWriter; import com.study.course_registration.domain.schedule.ScheduleSlot; @@ -91,9 +93,7 @@ public class JpaRegistrationPersistenceAdapter implements RegistrationReader, Re public void cancel(String registrationId, Instant canceledAt) { UserLesson registration = registrations.findById(registrationId) .orElseThrow(ResourceNotFound::registration); - if (!registration.isCanceled()) { - registration.cancel(canceledAt); - registrations.saveAndFlush(registration); - } + registration.cancel(canceledAt); + registrations.saveAndFlush(registration); } } diff --git a/src/main/java/com/study/course_registration/entity/RegistrationIdempotency.java b/src/main/java/com/study/course_registration/infrastructure/persistence/idempotency/RegistrationIdempotencyEntity.java similarity index 58% rename from src/main/java/com/study/course_registration/entity/RegistrationIdempotency.java rename to src/main/java/com/study/course_registration/infrastructure/persistence/idempotency/RegistrationIdempotencyEntity.java index 5495663..614a234 100644 --- a/src/main/java/com/study/course_registration/entity/RegistrationIdempotency.java +++ b/src/main/java/com/study/course_registration/infrastructure/persistence/idempotency/RegistrationIdempotencyEntity.java @@ -1,8 +1,13 @@ -package com.study.course_registration.entity; +package com.study.course_registration.infrastructure.persistence.idempotency; import java.time.Instant; import java.util.Objects; +import com.study.course_registration.entity.BaseCreateEntity; +import com.study.course_registration.entity.Lesson; +import com.study.course_registration.entity.User; +import com.study.course_registration.entity.UserLesson; + import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.FetchType; @@ -22,7 +27,7 @@ import lombok.NoArgsConstructor; uniqueConstraints = @UniqueConstraint( name = "uk_registration_idempotency", columnNames = {"user_id", "idempotency_key"})) -public class RegistrationIdempotency extends BaseCreateEntity { +public class RegistrationIdempotencyEntity extends BaseCreateEntity { @ManyToOne(fetch = FetchType.LAZY, optional = false) @JoinColumn(name = "user_id", nullable = false, foreignKey = @ForeignKey(name = "fk_idempotency_user")) private User user; @@ -41,17 +46,33 @@ public class RegistrationIdempotency extends BaseCreateEntity { @Column(name = "idempotency_key", nullable = false, length = 100) private String idempotencyKey; + @Column(name = "lesson_name", nullable = false) + private String lessonName; + + @Column(name = "subject_code", nullable = false) + private String subjectCode; + + @Column(name = "credit", nullable = false) + private Integer credit; + + @Column(name = "registered_at", nullable = false) + private Instant registeredAt; + @Column(name = "total_credits", nullable = false) private Integer totalCredits; @Column(name = "expires_at", nullable = false) private Instant expiresAt; - public RegistrationIdempotency( + public RegistrationIdempotencyEntity( User user, Lesson lesson, UserLesson registration, String idempotencyKey, + String lessonName, + String subjectCode, + Integer credit, + Instant registeredAt, Integer totalCredits, Instant expiresAt) { this.user = Objects.requireNonNull(user, "user"); @@ -61,7 +82,24 @@ public class RegistrationIdempotency extends BaseCreateEntity { throw new IllegalArgumentException("idempotencyKey length must be 1..100"); } this.idempotencyKey = idempotencyKey; - this.totalCredits = Objects.requireNonNull(totalCredits, "totalCredits"); + this.lessonName = requireText(lessonName, "lessonName"); + this.subjectCode = requireText(subjectCode, "subjectCode"); + if (credit == null || credit < 1) { + throw new IllegalArgumentException("credit must be at least 1"); + } + this.credit = credit; + this.registeredAt = Objects.requireNonNull(registeredAt, "registeredAt"); + if (totalCredits == null || totalCredits < 1) { + throw new IllegalArgumentException("totalCredits must be at least 1"); + } + this.totalCredits = totalCredits; this.expiresAt = Objects.requireNonNull(expiresAt, "expiresAt"); } + + private static String requireText(String value, String field) { + if (value == null || value.isBlank()) { + throw new IllegalArgumentException(field + " must not be blank"); + } + return value; + } } diff --git a/src/main/java/com/study/course_registration/infrastructure/persistence/repository/RegistrationIdempotencyRepository.java b/src/main/java/com/study/course_registration/infrastructure/persistence/repository/RegistrationIdempotencyRepository.java index 23de8b0..5355ae2 100644 --- a/src/main/java/com/study/course_registration/infrastructure/persistence/repository/RegistrationIdempotencyRepository.java +++ b/src/main/java/com/study/course_registration/infrastructure/persistence/repository/RegistrationIdempotencyRepository.java @@ -1,8 +1,10 @@ package com.study.course_registration.infrastructure.persistence.repository; import java.time.Instant; +import java.util.List; import java.util.Optional; +import org.springframework.data.domain.Pageable; import org.springframework.data.jpa.repository.EntityGraph; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Modifying; @@ -10,32 +12,23 @@ import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.query.Param; import org.springframework.transaction.annotation.Transactional; -import com.study.course_registration.entity.RegistrationIdempotency; +import com.study.course_registration.infrastructure.persistence.idempotency.RegistrationIdempotencyEntity; -public interface RegistrationIdempotencyRepository extends JpaRepository { - @EntityGraph(attributePaths = { - "user", "lesson", "lesson.subject", "registration" - }) - Optional findByUser_IdAndIdempotencyKeyAndExpiresAtAfter( +public interface RegistrationIdempotencyRepository extends JpaRepository { + @EntityGraph(attributePaths = {"user", "lesson", "registration"}) + Optional findByUser_IdAndIdempotencyKeyAndExpiresAtAfter( String userId, String idempotencyKey, Instant now); @Modifying @Transactional - @Query(""" - delete from RegistrationIdempotency value - where value.user.id = :userId - and value.idempotencyKey = :idempotencyKey - and value.expiresAt <= :now - """) + @Query("delete from RegistrationIdempotencyEntity value where value.user.id = :userId and value.idempotencyKey = :idempotencyKey and value.expiresAt <= :now") int deleteExpiredKey( @Param("userId") String userId, @Param("idempotencyKey") String idempotencyKey, @Param("now") Instant now); - @Modifying - @Transactional - @Query("delete from RegistrationIdempotency value where value.expiresAt <= :now") - int deleteExpired(@Param("now") Instant now); + @Query("select value.id from RegistrationIdempotencyEntity value where value.expiresAt <= :now order by value.expiresAt asc, value.id asc") + List findExpiredIds(@Param("now") Instant now, Pageable pageable); } diff --git a/src/main/java/com/study/course_registration/infrastructure/scheduling/DatabaseJobLock.java b/src/main/java/com/study/course_registration/infrastructure/scheduling/DatabaseJobLock.java new file mode 100644 index 0000000..92cb5d0 --- /dev/null +++ b/src/main/java/com/study/course_registration/infrastructure/scheduling/DatabaseJobLock.java @@ -0,0 +1,36 @@ +package com.study.course_registration.infrastructure.scheduling; + +import java.util.OptionalInt; +import java.util.function.IntSupplier; + +import org.springframework.dao.TransientDataAccessException; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import org.springframework.transaction.support.TransactionTemplate; + +@Component +public class DatabaseJobLock { + private final JdbcTemplate jdbcTemplate; + private final TransactionTemplate transactionTemplate; + + public DatabaseJobLock(JdbcTemplate jdbcTemplate, TransactionTemplate transactionTemplate) { + this.jdbcTemplate = jdbcTemplate; + this.transactionTemplate = transactionTemplate; + } + + public OptionalInt callWithLock(String name, IntSupplier task) { + Integer result = transactionTemplate.execute(status -> { + try { + jdbcTemplate.queryForObject( + "select name from maintenance_locks where name = ? for update nowait", + String.class, + name); + } catch (TransientDataAccessException exception) { + status.setRollbackOnly(); + return null; + } + return task.getAsInt(); + }); + return result == null ? OptionalInt.empty() : OptionalInt.of(result); + } +} diff --git a/src/main/java/com/study/course_registration/infrastructure/scheduling/IdempotencyRetentionJob.java b/src/main/java/com/study/course_registration/infrastructure/scheduling/IdempotencyRetentionJob.java index fed0c60..9c8d9d2 100644 --- a/src/main/java/com/study/course_registration/infrastructure/scheduling/IdempotencyRetentionJob.java +++ b/src/main/java/com/study/course_registration/infrastructure/scheduling/IdempotencyRetentionJob.java @@ -1,20 +1,39 @@ package com.study.course_registration.infrastructure.scheduling; +import java.util.OptionalInt; + +import org.springframework.beans.factory.annotation.Value; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; -import com.study.course_registration.application.idempotency.CleanupIdempotencyUseCase; +import com.study.course_registration.application.registration.idempotency.CleanupIdempotencyUseCase; @Component public class IdempotencyRetentionJob { - private final CleanupIdempotencyUseCase cleanupIdempotencyUseCase; + static final String LOCK_NAME = "idempotency-cleanup"; - public IdempotencyRetentionJob(CleanupIdempotencyUseCase cleanupIdempotencyUseCase) { + private final CleanupIdempotencyUseCase cleanupIdempotencyUseCase; + private final DatabaseJobLock jobLock; + private final int maxBatchesPerRun; + + public IdempotencyRetentionJob( + CleanupIdempotencyUseCase cleanupIdempotencyUseCase, + DatabaseJobLock jobLock, + @Value("${app.idempotency.cleanup-max-batches-per-run:20}") int maxBatchesPerRun) { this.cleanupIdempotencyUseCase = cleanupIdempotencyUseCase; + this.jobLock = jobLock; + this.maxBatchesPerRun = maxBatchesPerRun; } @Scheduled(fixedDelayString = "${app.idempotency.cleanup-delay-ms:3600000}") public void cleanup() { - cleanupIdempotencyUseCase.execute(); + for (int index = 0; index < maxBatchesPerRun; index++) { + OptionalInt deleted = jobLock.callWithLock( + LOCK_NAME, + cleanupIdempotencyUseCase::execute); + if (deleted.isEmpty() || deleted.getAsInt() == 0) { + return; + } + } } } diff --git a/src/main/java/com/study/course_registration/web/error/ApiExceptionHandler.java b/src/main/java/com/study/course_registration/web/error/ApiExceptionHandler.java index 53349fb..591be88 100644 --- a/src/main/java/com/study/course_registration/web/error/ApiExceptionHandler.java +++ b/src/main/java/com/study/course_registration/web/error/ApiExceptionHandler.java @@ -1,19 +1,29 @@ package com.study.course_registration.web.error; +import java.sql.SQLException; +import java.sql.SQLTransientConnectionException; import java.time.Clock; import java.util.concurrent.ThreadLocalRandom; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.springframework.dao.DataAccessResourceFailureException; import org.springframework.dao.PessimisticLockingFailureException; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.http.converter.HttpMessageNotReadableException; +import org.springframework.web.HttpMediaTypeNotSupportedException; +import org.springframework.web.HttpRequestMethodNotSupportedException; +import org.springframework.web.bind.MissingServletRequestParameterException; import org.springframework.web.bind.MethodArgumentNotValidException; import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.bind.annotation.RestControllerAdvice; +import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException; +import org.springframework.web.servlet.resource.NoResourceFoundException; +import com.study.course_registration.domain.registration.RegistrationInvariantViolation; +import com.study.course_registration.domain.registration.RegistrationRejection; import com.study.course_registration.enums.RegistrationErrorCode; import com.study.course_registration.failure.ApplicationFailure; import com.study.course_registration.failure.RetryableInfrastructureFailure; @@ -40,8 +50,8 @@ public class ApiExceptionHandler { @ExceptionHandler(RetryableInfrastructureFailure.class) ResponseEntity retryable(RetryableInfrastructureFailure failure) { metrics.record(failure); - log.warn("Retryable infrastructure failure: {}", failure.getMessage()); - return lockTimeoutResponse(failure.getMessage()); + log.warn("Retryable infrastructure failure [{}]: {}", failure.reason(), failure.getMessage()); + return retryableResponse(failure.getErrorCode(), failure.getMessage()); } @ExceptionHandler(ApplicationFailure.class) @@ -65,6 +75,41 @@ public class ApiExceptionHandler { return badRequest("요청 값이 올바르지 않습니다."); } + @ExceptionHandler({MethodArgumentTypeMismatchException.class, MissingServletRequestParameterException.class}) + ResponseEntity requestBinding(Exception exception) { + return badRequest("요청 값이 올바르지 않습니다."); + } + + @ExceptionHandler(NoResourceFoundException.class) + ResponseEntity notFound(NoResourceFoundException exception) { + return response(HttpStatus.NOT_FOUND, "NOT_FOUND", "요청한 API를 찾을 수 없습니다."); + } + + @ExceptionHandler(HttpRequestMethodNotSupportedException.class) + ResponseEntity methodNotAllowed(HttpRequestMethodNotSupportedException exception) { + return response(HttpStatus.METHOD_NOT_ALLOWED, "METHOD_NOT_ALLOWED", "지원하지 않는 HTTP 메서드입니다."); + } + + @ExceptionHandler(HttpMediaTypeNotSupportedException.class) + ResponseEntity unsupportedMediaType(HttpMediaTypeNotSupportedException exception) { + return response(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "UNSUPPORTED_MEDIA_TYPE", "지원하지 않는 Content-Type입니다."); + } + + @ExceptionHandler(RegistrationRejection.class) + ResponseEntity registrationRejected(RegistrationRejection rejection) { + metrics.record(rejection); + return ResponseEntity.status(httpMapper.map(rejection.code())) + .body(new ApiErrorResponse(rejection.code().name(), rejection.getMessage(), clock.instant())); + } + + @ExceptionHandler(RegistrationInvariantViolation.class) + ResponseEntity registrationInvariant(RegistrationInvariantViolation failure) { + metrics.record(failure); + log.error("Registration invariant violation [{}]", failure.invariant(), failure); + return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) + .body(body(RegistrationErrorCode.INTERNAL_SERVER_ERROR, "서버 내부 오류가 발생했습니다.")); + } + @ExceptionHandler(SystemInvariantViolation.class) ResponseEntity invariant(SystemInvariantViolation failure) { metrics.record(failure); @@ -75,8 +120,21 @@ public class ApiExceptionHandler { @ExceptionHandler({LockTimeoutException.class, PessimisticLockException.class, PessimisticLockingFailureException.class}) ResponseEntity rawLockTimeout(Exception exception) { - log.warn("Persistence lock timeout: {}", exception.getMessage()); - return lockTimeoutResponse("다른 요청이 처리 중입니다. 잠시 후 다시 시도해 주세요."); + return retryable(RetryableInfrastructureFailure.lockTimeout(exception)); + } + + @ExceptionHandler(DataAccessResourceFailureException.class) + ResponseEntity databaseResourceFailure(DataAccessResourceFailureException exception) { + SQLException sqlException = findSqlException(exception); + if (sqlException != null + && sqlException.getSQLState() != null + && sqlException.getSQLState().startsWith("08")) { + return retryable(RetryableInfrastructureFailure.dbUnavailable(exception)); + } + if (hasTransientConnectionCause(exception)) { + return retryable(RetryableInfrastructureFailure.dbPoolExhausted(exception)); + } + return retryable(RetryableInfrastructureFailure.dbUnavailable(exception)); } @ExceptionHandler(Exception.class) @@ -91,11 +149,40 @@ public class ApiExceptionHandler { .body(body(RegistrationErrorCode.VALIDATION_ERROR, message)); } - private ResponseEntity lockTimeoutResponse(String message) { + private ResponseEntity response(HttpStatus status, String code, String message) { + return ResponseEntity.status(status) + .body(new ApiErrorResponse(code, message, clock.instant())); + } + + private ResponseEntity retryableResponse( + RegistrationErrorCode code, + String message) { String retryAfter = Integer.toString(ThreadLocalRandom.current().nextInt(1, 4)); return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE) .header(HttpHeaders.RETRY_AFTER, retryAfter) - .body(body(RegistrationErrorCode.LOCK_TIMEOUT, message)); + .body(body(code, message)); + } + + private static SQLException findSqlException(Throwable failure) { + Throwable current = failure; + while (current != null) { + if (current instanceof SQLException sqlException) { + return sqlException; + } + current = current.getCause(); + } + return null; + } + + private static boolean hasTransientConnectionCause(Throwable failure) { + Throwable current = failure; + while (current != null) { + if (current instanceof SQLTransientConnectionException) { + return true; + } + current = current.getCause(); + } + return false; } private ApiErrorResponse body(RegistrationErrorCode code, String message) { diff --git a/src/main/java/com/study/course_registration/web/error/FailureHttpMapper.java b/src/main/java/com/study/course_registration/web/error/FailureHttpMapper.java index 00660bb..93c2c2f 100644 --- a/src/main/java/com/study/course_registration/web/error/FailureHttpMapper.java +++ b/src/main/java/com/study/course_registration/web/error/FailureHttpMapper.java @@ -3,6 +3,7 @@ package com.study.course_registration.web.error; import org.springframework.http.HttpStatus; import org.springframework.stereotype.Component; +import com.study.course_registration.domain.registration.RegistrationRejectionCode; import com.study.course_registration.enums.RegistrationErrorCode; @Component @@ -17,8 +18,16 @@ public class FailureHttpMapper { case REGISTRATION_PERIOD_CLOSED, ALREADY_REGISTERED, DUPLICATE_SUBJECT, SCHEDULE_CONFLICT, CREDIT_LIMIT_EXCEEDED, CAPACITY_EXCEEDED, IDEMPOTENCY_KEY_REUSED -> HttpStatus.CONFLICT; - case LOCK_TIMEOUT -> HttpStatus.SERVICE_UNAVAILABLE; + case LOCK_TIMEOUT, DB_POOL_EXHAUSTED, DB_UNAVAILABLE -> HttpStatus.SERVICE_UNAVAILABLE; case INTERNAL_SERVER_ERROR -> HttpStatus.INTERNAL_SERVER_ERROR; }; } + + public HttpStatus map(RegistrationRejectionCode code) { + return switch (code) { + case NOT_ELIGIBLE_GRADE, NOT_ELIGIBLE_ROLE -> HttpStatus.FORBIDDEN; + case REGISTRATION_PERIOD_CLOSED, ALREADY_REGISTERED, DUPLICATE_SUBJECT, + SCHEDULE_CONFLICT, CREDIT_LIMIT_EXCEEDED, CAPACITY_EXCEEDED -> HttpStatus.CONFLICT; + }; + } } diff --git a/src/main/java/com/study/course_registration/web/error/FailureMetrics.java b/src/main/java/com/study/course_registration/web/error/FailureMetrics.java index a014efd..280832c 100644 --- a/src/main/java/com/study/course_registration/web/error/FailureMetrics.java +++ b/src/main/java/com/study/course_registration/web/error/FailureMetrics.java @@ -2,8 +2,9 @@ package com.study.course_registration.web.error; import org.springframework.stereotype.Component; +import com.study.course_registration.domain.registration.RegistrationInvariantViolation; +import com.study.course_registration.domain.registration.RegistrationRejection; import com.study.course_registration.failure.ApplicationFailure; -import com.study.course_registration.failure.BusinessRejection; import com.study.course_registration.failure.KnownFailure; import com.study.course_registration.failure.RetryableInfrastructureFailure; import com.study.course_registration.failure.SystemInvariantViolation; @@ -19,17 +20,26 @@ public class FailureMetrics { } public void record(KnownFailure failure) { - String category = failure instanceof BusinessRejection - ? "business_rejection" - : failure instanceof RetryableInfrastructureFailure - ? "retryable_infrastructure" - : failure instanceof ApplicationFailure - ? "application_failure" - : "known_failure"; + String category = failure instanceof RetryableInfrastructureFailure + ? "retryable_infrastructure" + : failure instanceof ApplicationFailure + ? "application_failure" + : "known_failure"; + String reason = failure instanceof RetryableInfrastructureFailure retryable + ? retryable.reason().name().toLowerCase() + : failure.getErrorCode().name().toLowerCase(); registry.counter( "application_failure_total", "category", category, - "reason", failure.getErrorCode().name().toLowerCase()) + "reason", reason) + .increment(); + } + + public void record(RegistrationRejection rejection) { + registry.counter( + "application_failure_total", + "category", "business_rejection", + "reason", rejection.code().name().toLowerCase()) .increment(); } @@ -39,4 +49,11 @@ public class FailureMetrics { "reason", failure.getInvariantCode().name().toLowerCase()) .increment(); } + + public void record(RegistrationInvariantViolation failure) { + registry.counter( + "system_invariant_violation_total", + "reason", failure.invariant().name().toLowerCase()) + .increment(); + } } diff --git a/src/main/resources/application.yaml b/src/main/resources/application.yaml index 4467758..d4a1aa7 100644 --- a/src/main/resources/application.yaml +++ b/src/main/resources/application.yaml @@ -16,7 +16,7 @@ spring: datasource: url: ${DB_URL} hikari: - connection-timeout: 2000 + connection-timeout: ${DB_CONNECTION_TIMEOUT_MS:5000} validation-timeout: 1000 maximum-pool-size: ${DB_POOL_MAX_SIZE:20} minimum-idle: ${DB_POOL_MIN_IDLE:2} @@ -47,3 +47,5 @@ app: idempotency: ttl-seconds: 86400 cleanup-delay-ms: 3600000 + cleanup-batch-size: 500 + cleanup-max-batches-per-run: 20 diff --git a/src/main/resources/db/migration/h2/V1__baseline.sql b/src/main/resources/db/migration/h2/V1__baseline.sql index d219f95..d9c4552 100644 --- a/src/main/resources/db/migration/h2/V1__baseline.sql +++ b/src/main/resources/db/migration/h2/V1__baseline.sql @@ -107,6 +107,10 @@ CREATE TABLE registration_idempotencies ( lesson_id VARCHAR(36) NOT NULL, registration_id VARCHAR(36) NOT NULL, idempotency_key VARCHAR(100) NOT NULL, + lesson_name VARCHAR(255) NOT NULL, + subject_code VARCHAR(255) NOT NULL, + credit INTEGER NOT NULL, + registered_at TIMESTAMP WITH TIME ZONE NOT NULL, total_credits INTEGER NOT NULL, created_at TIMESTAMP WITH TIME ZONE NOT NULL, expires_at TIMESTAMP WITH TIME ZONE NOT NULL, @@ -122,3 +126,8 @@ CREATE TABLE seed_locks ( name VARCHAR(100) PRIMARY KEY ); INSERT INTO seed_locks(name) VALUES ('demo-dataset'); + +CREATE TABLE maintenance_locks ( + name VARCHAR(100) PRIMARY KEY +); +INSERT INTO maintenance_locks(name) VALUES ('idempotency-cleanup'); diff --git a/src/main/resources/db/migration/postgresql/V1__baseline.sql b/src/main/resources/db/migration/postgresql/V1__baseline.sql index 12b8dde..624beb5 100644 --- a/src/main/resources/db/migration/postgresql/V1__baseline.sql +++ b/src/main/resources/db/migration/postgresql/V1__baseline.sql @@ -107,6 +107,10 @@ CREATE TABLE registration_idempotencies ( lesson_id VARCHAR(36) NOT NULL, registration_id VARCHAR(36) NOT NULL, idempotency_key VARCHAR(100) NOT NULL, + lesson_name VARCHAR(255) NOT NULL, + subject_code VARCHAR(255) NOT NULL, + credit INTEGER NOT NULL, + registered_at TIMESTAMP WITH TIME ZONE NOT NULL, total_credits INTEGER NOT NULL, created_at TIMESTAMP WITH TIME ZONE NOT NULL, expires_at TIMESTAMP WITH TIME ZONE NOT NULL, @@ -122,3 +126,8 @@ CREATE TABLE seed_locks ( name VARCHAR(100) PRIMARY KEY ); INSERT INTO seed_locks(name) VALUES ('demo-dataset'); + +CREATE TABLE maintenance_locks ( + name VARCHAR(100) PRIMARY KEY +); +INSERT INTO maintenance_locks(name) VALUES ('idempotency-cleanup'); diff --git a/src/test/java/com/study/course_registration/application/registration/CourseRegistrationConcurrencyIntegrationTest.java b/src/test/java/com/study/course_registration/application/registration/CourseRegistrationConcurrencyIntegrationTest.java index 4a25301..6bcd787 100644 --- a/src/test/java/com/study/course_registration/application/registration/CourseRegistrationConcurrencyIntegrationTest.java +++ b/src/test/java/com/study/course_registration/application/registration/CourseRegistrationConcurrencyIntegrationTest.java @@ -19,6 +19,7 @@ import org.springframework.beans.factory.annotation.Autowired; import com.study.course_registration.application.registration.RegisterCourseCommand; import com.study.course_registration.application.registration.RegisterCourseUseCase; +import com.study.course_registration.domain.registration.RegistrationRejection; import com.study.course_registration.entity.Lesson; import com.study.course_registration.entity.Professor; import com.study.course_registration.entity.Semester; @@ -170,6 +171,9 @@ class CourseRegistrationConcurrencyIntegrationTest extends PostgresIntegrationTe start.await(); action.run(); results.add(new Accepted()); + } catch (RegistrationRejection rejection) { + results.add(new Rejected( + RegistrationErrorCode.valueOf(rejection.code().name()))); } catch (ApplicationFailure exception) { results.add(new Rejected(exception.getErrorCode())); } catch (Throwable throwable) { diff --git a/src/test/java/com/study/course_registration/application/registration/RegisterCourseUseCaseTest.java b/src/test/java/com/study/course_registration/application/registration/RegisterCourseUseCaseTest.java index fa081d1..544f0d0 100644 --- a/src/test/java/com/study/course_registration/application/registration/RegisterCourseUseCaseTest.java +++ b/src/test/java/com/study/course_registration/application/registration/RegisterCourseUseCaseTest.java @@ -14,10 +14,10 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.mockito.InOrder; -import com.study.course_registration.application.idempotency.IdempotencyCoordinator; -import com.study.course_registration.application.idempotency.IdempotencyCoordinator.Decision; -import com.study.course_registration.application.idempotency.port.IdempotencyPort.ReplayRecord; -import com.study.course_registration.application.registration.port.RegistrationDecisionContextLoader; +import com.study.course_registration.application.registration.idempotency.IdempotencyCoordinator; +import com.study.course_registration.application.registration.idempotency.IdempotencyCoordinator.Decision; +import com.study.course_registration.application.registration.idempotency.model.IdempotencyReplay; +import com.study.course_registration.application.registration.port.RegistrationDecisionSnapshotLoader; import com.study.course_registration.application.registration.port.RegistrationExecutionScopeLoader; import com.study.course_registration.application.registration.port.RegistrationWriter; import com.study.course_registration.domain.registration.RegistrationExecutionScope; @@ -30,7 +30,7 @@ class RegisterCourseUseCaseTest { @DisplayName("idempotency replay → decision context 조회와 write 없이 즉시 반환") void replaySkipsDecisionContextLoading() { RegistrationExecutionScopeLoader scopes = mock(RegistrationExecutionScopeLoader.class); - RegistrationDecisionContextLoader contexts = mock(RegistrationDecisionContextLoader.class); + RegistrationDecisionSnapshotLoader contexts = mock(RegistrationDecisionSnapshotLoader.class); RegistrationWriter registrations = mock(RegistrationWriter.class); RegistrationPolicy policy = mock(RegistrationPolicy.class); RegistrationWindowGuard windowGuard = mock(RegistrationWindowGuard.class); @@ -38,7 +38,7 @@ class RegisterCourseUseCaseTest { RegistrationExecutionScope scope = new RegistrationExecutionScope("user", "lesson"); - ReplayRecord replay = new ReplayRecord( + IdempotencyReplay replay = new IdempotencyReplay( "registration", "user", "lesson", diff --git a/src/test/java/com/study/course_registration/application/registration/RegistrationUseCaseIntegrationTest.java b/src/test/java/com/study/course_registration/application/registration/RegistrationUseCaseIntegrationTest.java index fa65439..cca5e8b 100644 --- a/src/test/java/com/study/course_registration/application/registration/RegistrationUseCaseIntegrationTest.java +++ b/src/test/java/com/study/course_registration/application/registration/RegistrationUseCaseIntegrationTest.java @@ -15,6 +15,7 @@ import com.study.course_registration.application.registration.RegisterCourseComm import com.study.course_registration.application.registration.RegisterCourseUseCase; import com.study.course_registration.application.registration.RegistrationListResult; import com.study.course_registration.application.registration.RegistrationResult; +import com.study.course_registration.domain.registration.RegistrationRejection; import com.study.course_registration.entity.Lesson; import com.study.course_registration.entity.Professor; import com.study.course_registration.entity.Semester; @@ -32,7 +33,11 @@ import com.study.course_registration.support.fixture.DomainFixtures; import com.study.course_registration.support.fixture.TestData; class RegistrationUseCaseIntegrationTest extends PostgresIntegrationTest { - private static final Rejections REJECTIONS = + private static final Rejections REGISTRATION_REJECTIONS = + Rejections.of( + RegistrationRejection.class, + rejection -> RegistrationErrorCode.valueOf(rejection.code().name())); + private static final Rejections APPLICATION_FAILURES = Rejections.of(ApplicationFailure.class, ApplicationFailure::getErrorCode); @Autowired RegisterCourseUseCase registerCourse; @@ -72,7 +77,7 @@ class RegistrationUseCaseIntegrationTest extends PostgresIntegrationTest { .when(current -> register( current.student().getId(), current.lesson().getId())) - .thenRejectedWith(REJECTIONS, RegistrationErrorCode.ALREADY_REGISTERED); + .thenRejectedWith(REGISTRATION_REJECTIONS, RegistrationErrorCode.ALREADY_REGISTERED); } @Test @@ -101,7 +106,7 @@ class RegistrationUseCaseIntegrationTest extends PostgresIntegrationTest { Scenario.given(other) .whenRunning(user -> cancelRegistration.execute(user.getId(), registration.registrationId())) - .thenRejectedWith(REJECTIONS, RegistrationErrorCode.REGISTRATION_FORBIDDEN); + .thenRejectedWith(APPLICATION_FAILURES, RegistrationErrorCode.REGISTRATION_FORBIDDEN); } @Test @@ -237,7 +242,7 @@ class RegistrationUseCaseIntegrationTest extends PostgresIntegrationTest { Scenario.given(student) .when(user -> register(user.getId(), lesson.getId())) - .thenRejectedWith(REJECTIONS, RegistrationErrorCode.REGISTRATION_PERIOD_CLOSED); + .thenRejectedWith(REGISTRATION_REJECTIONS, RegistrationErrorCode.REGISTRATION_PERIOD_CLOSED); } @Test @@ -268,7 +273,7 @@ class RegistrationUseCaseIntegrationTest extends PostgresIntegrationTest { void registrationListUserNotFound() { Scenario.given("missing") .when(userId -> getRegistrations.execute(userId, data.semester().getId())) - .thenRejectedWith(REJECTIONS, RegistrationErrorCode.USER_NOT_FOUND); + .thenRejectedWith(APPLICATION_FAILURES, RegistrationErrorCode.USER_NOT_FOUND); } @Test @@ -276,7 +281,7 @@ class RegistrationUseCaseIntegrationTest extends PostgresIntegrationTest { void registrationListExplicitSemesterNotFound() { Scenario.given("missing") .when(semesterId -> getRegistrations.execute(data.student().getId(), semesterId)) - .thenRejectedWith(REJECTIONS, RegistrationErrorCode.SEMESTER_NOT_FOUND); + .thenRejectedWith(APPLICATION_FAILURES, RegistrationErrorCode.SEMESTER_NOT_FOUND); } @Test @@ -302,7 +307,7 @@ class RegistrationUseCaseIntegrationTest extends PostgresIntegrationTest { Scenario.given(student) .when(user -> getRegistrations.execute(user.getId(), null)) - .thenRejectedWith(REJECTIONS, RegistrationErrorCode.SEMESTER_NOT_FOUND); + .thenRejectedWith(APPLICATION_FAILURES, RegistrationErrorCode.SEMESTER_NOT_FOUND); } @Test @@ -315,7 +320,7 @@ class RegistrationUseCaseIntegrationTest extends PostgresIntegrationTest { data.student().getId(), data.lesson().getId(), value)) - .thenRejectedWith(REJECTIONS, RegistrationErrorCode.VALIDATION_ERROR); + .thenRejectedWith(APPLICATION_FAILURES, RegistrationErrorCode.VALIDATION_ERROR); } private RegistrationResult register(String userId, String lessonId) { diff --git a/src/test/java/com/study/course_registration/application/registration/idempotency/CleanupIdempotencyUseCaseTest.java b/src/test/java/com/study/course_registration/application/registration/idempotency/CleanupIdempotencyUseCaseTest.java new file mode 100644 index 0000000..b8407d1 --- /dev/null +++ b/src/test/java/com/study/course_registration/application/registration/idempotency/CleanupIdempotencyUseCaseTest.java @@ -0,0 +1,39 @@ +package com.study.course_registration.application.registration.idempotency; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.time.Duration; +import java.time.ZoneOffset; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import com.study.course_registration.application.registration.idempotency.port.IdempotencyPort; +import com.study.course_registration.support.MutableClock; +import com.study.course_registration.support.fixture.TestData; + +class CleanupIdempotencyUseCaseTest { + @Test + @DisplayName("cleanup → 현재 시각 기준으로 설정된 batch 크기만 삭제") + void deletesSingleBatchAtCurrentTime() { + MutableClock clock = new MutableClock(TestData.NOW, ZoneOffset.UTC); + IdempotencyPort idempotencies = mock(IdempotencyPort.class); + CleanupIdempotencyUseCase useCase = + new CleanupIdempotencyUseCase(clock, idempotencies, 500); + when(idempotencies.deleteExpiredBatch(TestData.NOW, 500)).thenReturn(23); + + int deleted = useCase.execute(); + + assertThat(deleted).isEqualTo(23); + verify(idempotencies).deleteExpiredBatch(TestData.NOW, 500); + + clock.advance(Duration.ofSeconds(1)); + when(idempotencies.deleteExpiredBatch(TestData.NOW.plusSeconds(1), 500)).thenReturn(0); + + assertThat(useCase.execute()).isZero(); + verify(idempotencies).deleteExpiredBatch(TestData.NOW.plusSeconds(1), 500); + } +} diff --git a/src/test/java/com/study/course_registration/architecture/ArchitectureTest.java b/src/test/java/com/study/course_registration/architecture/ArchitectureTest.java index 1185b67..a4b2040 100644 --- a/src/test/java/com/study/course_registration/architecture/ArchitectureTest.java +++ b/src/test/java/com/study/course_registration/architecture/ArchitectureTest.java @@ -26,7 +26,7 @@ class ArchitectureTest { classes() .that().haveSimpleName("RegisterCourseUseCase") .should().dependOnClassesThat().haveSimpleName("RegistrationExecutionScopeLoader") - .andShould().dependOnClassesThat().haveSimpleName("RegistrationDecisionContextLoader") + .andShould().dependOnClassesThat().haveSimpleName("RegistrationDecisionSnapshotLoader") .check(classes); classes() diff --git a/src/test/java/com/study/course_registration/architecture/DatabaseSchemaParityTest.java b/src/test/java/com/study/course_registration/architecture/DatabaseSchemaParityTest.java new file mode 100644 index 0000000..8bd3239 --- /dev/null +++ b/src/test/java/com/study/course_registration/architecture/DatabaseSchemaParityTest.java @@ -0,0 +1,60 @@ +package com.study.course_registration.architecture; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +class DatabaseSchemaParityTest { + private static final Pattern CREATE_TABLE = Pattern.compile( + "CREATE\\s+TABLE\\s+([A-Za-z0-9_]+)\\s*\\((.*?)\\);", + Pattern.CASE_INSENSITIVE | Pattern.DOTALL); + + @Test + @DisplayName("H2/PostgreSQL baseline → table·column 구조 동등") + void baselineSchemasHaveSameTablesAndColumns() throws IOException { + Map> postgres = tables(Path.of( + "src/main/resources/db/migration/postgresql/V1__baseline.sql")); + Map> h2 = tables(Path.of( + "src/main/resources/db/migration/h2/V1__baseline.sql")); + + assertThat(h2).isEqualTo(postgres); + } + + private static Map> tables(Path path) throws IOException { + String sql = Files.readString(path); + Matcher matcher = CREATE_TABLE.matcher(sql); + Map> tables = new LinkedHashMap<>(); + while (matcher.find()) { + tables.put(matcher.group(1).toLowerCase(), columns(matcher.group(2))); + } + return tables; + } + + private static Set columns(String body) { + Set columns = new LinkedHashSet<>(); + for (String rawLine : body.split("\\R")) { + String line = rawLine.trim(); + if (line.isEmpty() + || line.toUpperCase().startsWith("CONSTRAINT ") + || line.toUpperCase().startsWith("PRIMARY KEY") + || line.toUpperCase().startsWith("UNIQUE ") + || line.toUpperCase().startsWith("FOREIGN KEY")) { + continue; + } + String token = line.split("\\s+", 2)[0].replace(",", ""); + columns.add(token.toLowerCase()); + } + return columns; + } +} diff --git a/src/test/java/com/study/course_registration/architecture/ScenarioUsageTest.java b/src/test/java/com/study/course_registration/architecture/ScenarioUsageTest.java new file mode 100644 index 0000000..7b5a6ea --- /dev/null +++ b/src/test/java/com/study/course_registration/architecture/ScenarioUsageTest.java @@ -0,0 +1,108 @@ +package com.study.course_registration.architecture; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +class ScenarioUsageTest { + private static final String SCENARIO_GIVEN = "Scenario" + ".given("; + + @Test + @DisplayName("Scenario GWT → when 뒤 terminal assertion 필수") + void scenarioChainsMustEndWithAssertion() throws IOException { + List violations = new ArrayList<>(); + + try (Stream files = Files.walk(Path.of("src/test/java"))) { + files.filter(path -> path.toString().endsWith(".java")) + .filter(path -> !path.endsWith("ScenarioUsageTest.java")) + .forEach(path -> inspect(path, violations)); + } + + assertThat(violations) + .as("Scenario.given(...).when(...) 체인은 then 계열 assertion으로 종료해야 합니다.") + .isEmpty(); + } + + private static void inspect(Path path, List violations) { + try { + String source = Files.readString(path); + int cursor = 0; + while (true) { + int start = source.indexOf(SCENARIO_GIVEN, cursor); + if (start < 0) { + return; + } + int end = statementEnd(source, start); + if (end < 0) { + violations.add(path + " Scenario statement terminator not found"); + return; + } + String statement = source.substring(start, end + 1); + if (statement.contains(".when") && !statement.contains(".then")) { + int line = source.substring(0, start).split("\\R", -1).length; + violations.add(path + ":" + line + " missing terminal assertion"); + } + cursor = end + 1; + } + } catch (IOException exception) { + throw new IllegalStateException("Scenario usage 검사 실패: " + path, exception); + } + } + + private static int statementEnd(String source, int start) { + int parentheses = 0; + int braces = 0; + int brackets = 0; + boolean inString = false; + boolean inChar = false; + boolean escaped = false; + + for (int index = start; index < source.length(); index++) { + char current = source.charAt(index); + if (escaped) { + escaped = false; + continue; + } + if ((inString || inChar) && current == '\\') { + escaped = true; + continue; + } + if (!inChar && current == '"') { + inString = !inString; + continue; + } + if (!inString && current == '\'') { + inChar = !inChar; + continue; + } + if (inString || inChar) { + continue; + } + + if (current == '(') { + parentheses++; + } else if (current == ')') { + parentheses--; + } else if (current == '{') { + braces++; + } else if (current == '}') { + braces--; + } else if (current == '[') { + brackets++; + } else if (current == ']') { + brackets--; + } else if (current == ';' && parentheses == 0 && braces == 0 && brackets == 0) { + return index; + } + } + return -1; + } +} diff --git a/src/test/java/com/study/course_registration/domain/registration/RegistrationFixture.java b/src/test/java/com/study/course_registration/domain/registration/RegistrationFixture.java index 39e729e..dc6f35f 100644 --- a/src/test/java/com/study/course_registration/domain/registration/RegistrationFixture.java +++ b/src/test/java/com/study/course_registration/domain/registration/RegistrationFixture.java @@ -12,9 +12,6 @@ import com.study.course_registration.domain.registration.rule.AlreadyRegisteredR import com.study.course_registration.domain.registration.rule.CapacityRule; import com.study.course_registration.domain.registration.rule.CreditLimitRule; import com.study.course_registration.domain.registration.rule.DuplicateSubjectRule; -import com.study.course_registration.domain.registration.rule.GradeEligibilityRule; -import com.study.course_registration.domain.registration.rule.RegistrationPeriodRule; -import com.study.course_registration.domain.registration.rule.RoleEligibilityRule; import com.study.course_registration.domain.registration.rule.ScheduleAvailabilityRule; import com.study.course_registration.domain.registration.rule.ScheduleConflictRule; import com.study.course_registration.domain.schedule.ScheduleConflictChecker; @@ -146,7 +143,7 @@ final class RegistrationFixture { return registrationEndAt; } - private RegistrationContext context(Instant now) { + private RegistrationDecisionSnapshot context(Instant now) { UserProfile user = new UserProfile("user", grade, UserRole.STUDENT); LessonPolicySnapshot candidate = candidate(); @@ -176,7 +173,7 @@ final class RegistrationFixture { } } - return new RegistrationContext( + return new RegistrationDecisionSnapshot( user, candidate, active, @@ -204,9 +201,6 @@ final class RegistrationFixture { private static RegistrationPolicy policy() { ScheduleConflictChecker checker = new ScheduleConflictChecker(); return new RegistrationPolicy( - new RegistrationPeriodRule(), - new GradeEligibilityRule(), - new RoleEligibilityRule(), new AlreadyRegisteredRule(), new DuplicateSubjectRule(), new ScheduleAvailabilityRule(), diff --git a/src/test/java/com/study/course_registration/domain/registration/RegistrationPolicyTest.java b/src/test/java/com/study/course_registration/domain/registration/RegistrationPolicyTest.java index f2c31bb..94efe3b 100644 --- a/src/test/java/com/study/course_registration/domain/registration/RegistrationPolicyTest.java +++ b/src/test/java/com/study/course_registration/domain/registration/RegistrationPolicyTest.java @@ -3,6 +3,8 @@ package com.study.course_registration.domain.registration; import static org.assertj.core.api.Assertions.assertThat; import java.time.DayOfWeek; +import java.time.Duration; +import java.time.ZoneOffset; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; @@ -12,18 +14,18 @@ import org.junit.jupiter.params.provider.CsvSource; import com.study.course_registration.enums.RegistrationErrorCode; import com.study.course_registration.enums.UserRole; -import com.study.course_registration.failure.ApplicationFailure; -import com.study.course_registration.failure.InvariantCode; -import com.study.course_registration.failure.SystemInvariantViolation; +import com.study.course_registration.support.MutableClock; import com.study.course_registration.support.Rejections; import com.study.course_registration.support.Scenario; @DisplayName("수강신청 정책") class RegistrationPolicyTest { - private static final Rejections REJECTIONS = - Rejections.of(ApplicationFailure.class, ApplicationFailure::getErrorCode); - private static final Rejections INVARIANTS = - Rejections.of(SystemInvariantViolation.class, SystemInvariantViolation::getInvariantCode); + private static final Rejections REJECTIONS = + Rejections.of( + RegistrationRejection.class, + rejection -> RegistrationErrorCode.valueOf(rejection.code().name())); + private static final Rejections INVARIANTS = + Rejections.of(RegistrationInvariantViolation.class, RegistrationInvariantViolation::invariant); @Nested @DisplayName("R1 신청 기간") @@ -42,6 +44,23 @@ class RegistrationPolicyTest { Scenario.given(fixture).when(f -> f.checkEligibilityAt(f.registrationEndAt())).thenAccepted(); } + @Test + @DisplayName("종료 정각 허용 → 1ns 이후 기간 종료 거부") + void endBoundaryWithMovingClock() { + RegistrationFixture fixture = RegistrationFixture.student(2); + MutableClock clock = new MutableClock(fixture.registrationEndAt(), ZoneOffset.UTC); + + Scenario.given(fixture) + .when(current -> current.checkEligibilityAt(clock.instant())) + .thenAccepted(); + + clock.advance(Duration.ofNanos(1)); + + Scenario.given(fixture) + .when(current -> current.checkEligibilityAt(clock.instant())) + .thenRejectedWith(REJECTIONS, RegistrationErrorCode.REGISTRATION_PERIOD_CLOSED); + } + @Test @DisplayName("기간 종료 + 학년 미달 → R1") void periodBeforeGrade() { @@ -133,7 +152,7 @@ class RegistrationPolicyTest { void missingCandidateSchedule() { Scenario.given(RegistrationFixture.student(2).withoutSchedule()) .when(RegistrationFixture::attempt) - .thenRejectedWith(INVARIANTS, InvariantCode.MISSING_CANDIDATE_LESSON_SCHEDULE); + .thenRejectedWith(INVARIANTS, RegistrationInvariant.MISSING_CANDIDATE_LESSON_SCHEDULE); } @Test @@ -141,7 +160,7 @@ class RegistrationPolicyTest { void missingExistingSchedule() { Scenario.given(RegistrationFixture.student(2).alreadyRegistered("old", 3).existingWithoutSchedule()) .when(RegistrationFixture::attempt) - .thenRejectedWith(INVARIANTS, InvariantCode.MISSING_EXISTING_LESSON_SCHEDULE); + .thenRejectedWith(INVARIANTS, RegistrationInvariant.MISSING_EXISTING_LESSON_SCHEDULE); } } diff --git a/src/test/java/com/study/course_registration/entity/EntityInvariantTest.java b/src/test/java/com/study/course_registration/entity/EntityInvariantTest.java index 5c0efa0..37a49e1 100644 --- a/src/test/java/com/study/course_registration/entity/EntityInvariantTest.java +++ b/src/test/java/com/study/course_registration/entity/EntityInvariantTest.java @@ -157,8 +157,8 @@ class EntityInvariantTest { } @Test - @DisplayName("같은 신청 두 번 취소 → 도메인 거부") - void doubleCancel() { + @DisplayName("같은 신청 두 번 취소 → 최초 취소 시각을 유지") + void doubleCancelIsIdempotent() { UserLesson registration = DomainFixtures.registration( DomainFixtures.student(2), DomainFixtures.lesson( @@ -166,23 +166,9 @@ class EntityInvariantTest { DomainFixtures.professor(), DomainFixtures.openSemester())); registration.cancel(TestData.NOW); + registration.cancel(TestData.NOW.plusSeconds(10)); - assertThatThrownBy(() -> registration.cancel(TestData.NOW)) - .isInstanceOf(IllegalStateException.class); - } - - @Test - @DisplayName("Idempotency-Key 공백 → 생성 거부") - void idempotencyBlank() { - User user = DomainFixtures.student(2); - Lesson lesson = DomainFixtures.lesson( - DomainFixtures.subject("CS"), - DomainFixtures.professor(), - DomainFixtures.openSemester()); - UserLesson registration = DomainFixtures.registration(user, lesson); - - assertThatThrownBy(() -> new RegistrationIdempotency(user, lesson, registration, " ", 3, TestData.NOW.plusSeconds(86400))) - .isInstanceOf(IllegalArgumentException.class); + assertThat(registration.getCanceledAt()).isEqualTo(TestData.NOW); } @Test diff --git a/src/test/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationExecutionScopeLoaderTest.java b/src/test/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationExecutionScopeLoaderTest.java index f09f286..d66b99b 100644 --- a/src/test/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationExecutionScopeLoaderTest.java +++ b/src/test/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationExecutionScopeLoaderTest.java @@ -3,6 +3,7 @@ package com.study.course_registration.infrastructure.persistence; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; import java.util.Optional; @@ -20,7 +21,7 @@ import com.study.course_registration.support.fixture.DomainFixtures; class JpaRegistrationExecutionScopeLoaderTest { @Test - @DisplayName("execution scope 확보 → User 다음 Lesson 순서로 직렬화") + @DisplayName("execution scope → User 직렬화 후 필요할 때 Lesson 직렬화") void userThenLesson() { UserRepository users = mock(UserRepository.class); LessonRepository lessons = mock(LessonRepository.class); @@ -38,10 +39,14 @@ class JpaRegistrationExecutionScopeLoaderTest { RegistrationExecutionScope scope = loader.open("user", "lesson"); + assertThat(scope.userId()).isEqualTo("user"); + assertThat(scope.lessonId()).isEqualTo("lesson"); + verifyNoInteractions(lessons); + + loader.lockLesson(scope); + InOrder order = inOrder(users, lessons); order.verify(users).findByIdForUpdate("user"); order.verify(lessons).findByIdForUpdate("lesson"); - assertThat(scope.userId()).isEqualTo("user"); - assertThat(scope.lessonId()).isEqualTo("lesson"); } } diff --git a/src/test/java/com/study/course_registration/infrastructure/persistence/repository/RegistrationIdempotencyRepositoryTest.java b/src/test/java/com/study/course_registration/infrastructure/persistence/repository/RegistrationIdempotencyRepositoryTest.java index 188fd5b..e4d3427 100644 --- a/src/test/java/com/study/course_registration/infrastructure/persistence/repository/RegistrationIdempotencyRepositoryTest.java +++ b/src/test/java/com/study/course_registration/infrastructure/persistence/repository/RegistrationIdempotencyRepositoryTest.java @@ -5,6 +5,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import java.time.DayOfWeek; import java.time.Instant; +import java.util.List; import org.hibernate.Hibernate; import org.junit.jupiter.api.BeforeEach; @@ -12,11 +13,12 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DataIntegrityViolationException; +import org.springframework.data.domain.PageRequest; import com.study.course_registration.entity.Lesson; -import com.study.course_registration.entity.RegistrationIdempotency; import com.study.course_registration.entity.Subject; import com.study.course_registration.entity.UserLesson; +import com.study.course_registration.infrastructure.persistence.idempotency.RegistrationIdempotencyEntity; import com.study.course_registration.support.PostgresIntegrationTest; import com.study.course_registration.support.Scenario; import com.study.course_registration.support.fixture.DatabaseFixture; @@ -39,10 +41,10 @@ class RegistrationIdempotencyRepositoryTest extends PostgresIntegrationTest { } @Test - @DisplayName("userId + key + 유효기간 조회 → 연관 graph와 lifecycle 로드") + @DisplayName("userId + key + 유효기간 조회 → replay snapshot과 필수 연관만 로드") void lookupGraph() { Instant expiresAt = TestData.NOW.plusSeconds(86400); - repository.saveAndFlush(idempotency("request-1", registration, data.lesson(), expiresAt)); + repository.saveAndFlush(idempotency("request-1", registration, data.lesson(), 3, expiresAt)); Scenario.given("request-1") .when(key -> repository @@ -54,9 +56,12 @@ class RegistrationIdempotencyRepositoryTest extends PostgresIntegrationTest { .then(stored -> { assertThat(Hibernate.isInitialized(stored.getUser())).isTrue(); assertThat(Hibernate.isInitialized(stored.getLesson())).isTrue(); - assertThat(Hibernate.isInitialized(stored.getLesson().getSubject())).isTrue(); assertThat(Hibernate.isInitialized(stored.getRegistration())).isTrue(); - assertThat(stored.getCreatedAt()).isNotNull(); + assertThat(stored.getLessonName()).isEqualTo(data.lesson().getName()); + assertThat(stored.getSubjectCode()).isEqualTo(data.subject().getCode()); + assertThat(stored.getCredit()).isEqualTo(data.subject().getCredit()); + assertThat(stored.getRegisteredAt()).isEqualTo(registration.getCreatedAt()); + assertThat(stored.getTotalCredits()).isEqualTo(3); assertThat(stored.getExpiresAt()).isEqualTo(expiresAt); }); } @@ -65,7 +70,7 @@ class RegistrationIdempotencyRepositoryTest extends PostgresIntegrationTest { @DisplayName("만료 key 삭제 → 같은 user + key 재사용 가능") void expiredKeyCanBeRemoved() { Instant expiredAt = TestData.NOW.minusSeconds(1); - repository.saveAndFlush(idempotency("request-expired", registration, data.lesson(), expiredAt)); + repository.saveAndFlush(idempotency("request-expired", registration, data.lesson(), 3, expiredAt)); Scenario.given("request-expired") .when(key -> repository.deleteExpiredKey( @@ -79,12 +84,13 @@ class RegistrationIdempotencyRepositoryTest extends PostgresIntegrationTest { } @Test - @DisplayName("만료 전체 정리 → expiresAt 지난 행만 삭제") - void deleteExpired() { - repository.saveAndFlush(idempotency( + @DisplayName("만료 정리 조회 → batch 크기만큼 오래된 id만 반환") + void findExpiredIdsIsBounded() { + RegistrationIdempotencyEntity expired = repository.saveAndFlush(idempotency( "expired", registration, data.lesson(), + 3, TestData.NOW.minusSeconds(1))); Subject subject = fixture.subject(DomainFixtures.subject("FRESH")); @@ -93,22 +99,18 @@ class RegistrationIdempotencyRepositoryTest extends PostgresIntegrationTest { fixture.schedule(DomainFixtures.schedule(freshLesson, DayOfWeek.TUESDAY, 13, 15)); UserLesson freshRegistration = fixture.registration( DomainFixtures.registration(data.student(), freshLesson)); - repository.saveAndFlush(new RegistrationIdempotency( - data.student(), - freshLesson, - freshRegistration, + repository.saveAndFlush(idempotency( "fresh", + freshRegistration, + freshLesson, 6, TestData.NOW.plusSeconds(86400))); - Scenario.given(TestData.NOW) - .when(repository::deleteExpired) - .then(deleted -> { - assertThat(deleted).isEqualTo(1); - assertThat(repository.findAll()) - .extracting(RegistrationIdempotency::getIdempotencyKey) - .containsExactly("fresh"); - }); + List expiredIds = repository.findExpiredIds( + TestData.NOW, + PageRequest.of(0, 1)); + + assertThat(expiredIds).containsExactly(expired.getId()); } @Test @@ -118,6 +120,7 @@ class RegistrationIdempotencyRepositoryTest extends PostgresIntegrationTest { "request-1", registration, data.lesson(), + 3, TestData.NOW.plusSeconds(86400))); Subject subject = fixture.subject(DomainFixtures.subject("OTHER")); @@ -127,11 +130,10 @@ class RegistrationIdempotencyRepositoryTest extends PostgresIntegrationTest { UserLesson otherRegistration = fixture.registration(DomainFixtures.registration(data.student(), otherLesson)); - assertThatThrownBy(() -> repository.saveAndFlush(new RegistrationIdempotency( - data.student(), - otherLesson, - otherRegistration, + assertThatThrownBy(() -> repository.saveAndFlush(idempotency( "request-1", + otherRegistration, + otherLesson, 6, TestData.NOW.plusSeconds(86400)))) .isInstanceOf(DataIntegrityViolationException.class); @@ -144,29 +146,34 @@ class RegistrationIdempotencyRepositoryTest extends PostgresIntegrationTest { "request-1", registration, data.lesson(), + 3, TestData.NOW.plusSeconds(86400))); - assertThatThrownBy(() -> repository.saveAndFlush(new RegistrationIdempotency( - data.student(), - data.lesson(), - registration, + assertThatThrownBy(() -> repository.saveAndFlush(idempotency( "request-2", + registration, + data.lesson(), 3, TestData.NOW.plusSeconds(86400)))) .isInstanceOf(DataIntegrityViolationException.class); } - private RegistrationIdempotency idempotency( + private RegistrationIdempotencyEntity idempotency( String key, UserLesson target, Lesson lesson, + int totalCredits, Instant expiresAt) { - return new RegistrationIdempotency( + return new RegistrationIdempotencyEntity( data.student(), lesson, target, key, - 3, + lesson.getName(), + lesson.getSubject().getCode(), + lesson.getSubject().getCredit(), + target.getCreatedAt(), + totalCredits, expiresAt); } } diff --git a/src/test/java/com/study/course_registration/infrastructure/scheduling/DatabaseJobLockTest.java b/src/test/java/com/study/course_registration/infrastructure/scheduling/DatabaseJobLockTest.java new file mode 100644 index 0000000..ce29177 --- /dev/null +++ b/src/test/java/com/study/course_registration/infrastructure/scheduling/DatabaseJobLockTest.java @@ -0,0 +1,76 @@ +package com.study.course_registration.infrastructure.scheduling; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.OptionalInt; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.jdbc.core.JdbcTemplate; + +import com.study.course_registration.support.CourseIntegrationTest; + +@CourseIntegrationTest +class DatabaseJobLockTest { + private static final String TEST_LOCK = "database-job-lock-test"; + + @Autowired DatabaseJobLock jobLock; + @Autowired JdbcTemplate jdbcTemplate; + + @Test + @DisplayName("같은 maintenance lock 동시 획득 → 한 실행만 진입") + void onlyOneConcurrentOwner() throws Exception { + jdbcTemplate.update("delete from maintenance_locks where name = ?", TEST_LOCK); + jdbcTemplate.update("insert into maintenance_locks(name) values (?)", TEST_LOCK); + + ExecutorService executor = Executors.newFixedThreadPool(2); + CountDownLatch entered = new CountDownLatch(1); + CountDownLatch release = new CountDownLatch(1); + + try { + Future first = executor.submit(() -> jobLock.callWithLock( + TEST_LOCK, + () -> { + entered.countDown(); + await(release); + return 1; + })); + + assertThat(entered.await(2, TimeUnit.SECONDS)).isTrue(); + + OptionalInt second = jobLock.callWithLock( + TEST_LOCK, + () -> { + throw new AssertionError("second owner must not execute"); + }); + + assertThat(second.isEmpty()).isTrue(); + release.countDown(); + + OptionalInt firstResult = first.get(5, TimeUnit.SECONDS); + assertThat(firstResult.isPresent()).isTrue(); + assertThat(firstResult.getAsInt()).isEqualTo(1); + } finally { + release.countDown(); + executor.shutdownNow(); + jdbcTemplate.update("delete from maintenance_locks where name = ?", TEST_LOCK); + } + } + + private static void await(CountDownLatch latch) { + try { + if (!latch.await(5, TimeUnit.SECONDS)) { + throw new IllegalStateException("lock test latch timeout"); + } + } catch (InterruptedException exception) { + Thread.currentThread().interrupt(); + throw new IllegalStateException("lock test interrupted", exception); + } + } +} diff --git a/src/test/java/com/study/course_registration/infrastructure/scheduling/IdempotencyRetentionJobTest.java b/src/test/java/com/study/course_registration/infrastructure/scheduling/IdempotencyRetentionJobTest.java index 2b89e5e..f75f6b2 100644 --- a/src/test/java/com/study/course_registration/infrastructure/scheduling/IdempotencyRetentionJobTest.java +++ b/src/test/java/com/study/course_registration/infrastructure/scheduling/IdempotencyRetentionJobTest.java @@ -1,23 +1,45 @@ package com.study.course_registration.infrastructure.scheduling; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.OptionalInt; +import java.util.function.IntSupplier; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -import com.study.course_registration.application.idempotency.CleanupIdempotencyUseCase; -import com.study.course_registration.infrastructure.scheduling.IdempotencyRetentionJob; +import com.study.course_registration.application.registration.idempotency.CleanupIdempotencyUseCase; class IdempotencyRetentionJobTest { @Test - @DisplayName("cleanup → CleanupIdempotencyUseCase 실행") - void cleanup() { + @DisplayName("cleanup batch 완료 후 빈 batch → 반복 종료") + void cleanupStopsOnEmptyBatch() { CleanupIdempotencyUseCase cleanup = mock(CleanupIdempotencyUseCase.class); - IdempotencyRetentionJob job = new IdempotencyRetentionJob(cleanup); + DatabaseJobLock jobLock = mock(DatabaseJobLock.class); + when(jobLock.callWithLock(eq(IdempotencyRetentionJob.LOCK_NAME), any(IntSupplier.class))) + .thenAnswer(invocation -> OptionalInt.of(invocation.getArgument(1).getAsInt())); + when(cleanup.execute()).thenReturn(500, 3, 0); + IdempotencyRetentionJob job = new IdempotencyRetentionJob(cleanup, jobLock, 20); job.cleanup(); - verify(cleanup).execute(); + verify(cleanup, org.mockito.Mockito.times(3)).execute(); + } + + @Test + @DisplayName("cleanup lock 미획득 → 삭제 실행 안 함") + void cleanupSkipsWhenLockIsOwnedByAnotherInstance() { + CleanupIdempotencyUseCase cleanup = mock(CleanupIdempotencyUseCase.class); + DatabaseJobLock jobLock = mock(DatabaseJobLock.class); + when(jobLock.callWithLock(eq(IdempotencyRetentionJob.LOCK_NAME), any(IntSupplier.class))) + .thenReturn(OptionalInt.empty()); + + new IdempotencyRetentionJob(cleanup, jobLock, 20).cleanup(); + + verify(cleanup, org.mockito.Mockito.never()).execute(); } } diff --git a/src/test/java/com/study/course_registration/support/MutableClock.java b/src/test/java/com/study/course_registration/support/MutableClock.java new file mode 100644 index 0000000..ae55e46 --- /dev/null +++ b/src/test/java/com/study/course_registration/support/MutableClock.java @@ -0,0 +1,47 @@ +package com.study.course_registration.support; + +import java.time.Clock; +import java.time.Duration; +import java.time.Instant; +import java.time.ZoneId; +import java.util.Objects; +import java.util.concurrent.atomic.AtomicReference; + +public final class MutableClock extends Clock { + private final AtomicReference current; + private final ZoneId zone; + + public MutableClock(Instant initialInstant, ZoneId zone) { + this(new AtomicReference<>(Objects.requireNonNull(initialInstant, "initialInstant")), + Objects.requireNonNull(zone, "zone")); + } + + private MutableClock(AtomicReference current, ZoneId zone) { + this.current = current; + this.zone = zone; + } + + public void set(Instant instant) { + current.set(Objects.requireNonNull(instant, "instant")); + } + + public void advance(Duration duration) { + Objects.requireNonNull(duration, "duration"); + current.updateAndGet(instant -> instant.plus(duration)); + } + + @Override + public ZoneId getZone() { + return zone; + } + + @Override + public Clock withZone(ZoneId targetZone) { + return new MutableClock(current, Objects.requireNonNull(targetZone, "targetZone")); + } + + @Override + public Instant instant() { + return current.get(); + } +} diff --git a/src/test/java/com/study/course_registration/support/fixture/TestFixtureConfig.java b/src/test/java/com/study/course_registration/support/fixture/TestFixtureConfig.java index 237cd38..2d854c3 100644 --- a/src/test/java/com/study/course_registration/support/fixture/TestFixtureConfig.java +++ b/src/test/java/com/study/course_registration/support/fixture/TestFixtureConfig.java @@ -1,6 +1,5 @@ package com.study.course_registration.support.fixture; -import java.time.Clock; import java.time.ZoneOffset; import org.springframework.boot.test.context.TestConfiguration; @@ -15,13 +14,14 @@ import com.study.course_registration.infrastructure.persistence.repository.Semes import com.study.course_registration.infrastructure.persistence.repository.SubjectRepository; import com.study.course_registration.infrastructure.persistence.repository.UserLessonRepository; import com.study.course_registration.infrastructure.persistence.repository.UserRepository; +import com.study.course_registration.support.MutableClock; @TestConfiguration(proxyBeanMethods = false) public class TestFixtureConfig { @Bean @Primary - Clock testClock() { - return Clock.fixed(TestData.NOW, ZoneOffset.UTC); + MutableClock testClock() { + return new MutableClock(TestData.NOW, ZoneOffset.UTC); } @Bean diff --git a/src/test/java/com/study/course_registration/web/error/ApiExceptionHandlerTest.java b/src/test/java/com/study/course_registration/web/error/ApiExceptionHandlerTest.java index 38c03f6..22b38a6 100644 --- a/src/test/java/com/study/course_registration/web/error/ApiExceptionHandlerTest.java +++ b/src/test/java/com/study/course_registration/web/error/ApiExceptionHandlerTest.java @@ -2,15 +2,19 @@ package com.study.course_registration.web.error; import static org.assertj.core.api.Assertions.assertThat; +import java.sql.SQLException; +import java.sql.SQLTransientConnectionException; import java.time.Clock; import java.time.ZoneOffset; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import org.springframework.dao.DataAccessResourceFailureException; import org.springframework.http.HttpHeaders; import org.springframework.http.ResponseEntity; -import com.study.course_registration.failure.BusinessRejection; +import com.study.course_registration.domain.registration.RegistrationRejection; +import com.study.course_registration.failure.RetryableInfrastructureFailure; import com.study.course_registration.failure.SystemInvariantViolation; import com.study.course_registration.support.fixture.TestData; @@ -29,7 +33,7 @@ class ApiExceptionHandlerTest { @DisplayName("business rejection → HTTP mapper 결과 + stacktrace 없는 정상 실패") void businessRejection() { ResponseEntity response = - handler.application(BusinessRejection.capacityExceeded(30, 30)); + handler.registrationRejected(RegistrationRejection.capacityExceeded(30, 30)); assertThat(response.getStatusCode().value()).isEqualTo(409); assertThat(response.getBody().code()).isEqualTo("CAPACITY_EXCEEDED"); @@ -48,6 +52,36 @@ class ApiExceptionHandlerTest { assertThat(response.getBody().code()).isEqualTo("LOCK_TIMEOUT"); } + @Test + @DisplayName("DB pool 고갈 → 503 DB_POOL_EXHAUSTED") + void dbPoolExhausted() { + ResponseEntity response = handler.retryable( + RetryableInfrastructureFailure.dbPoolExhausted( + new SQLTransientConnectionException("pool exhausted"))); + + assertThat(response.getStatusCode().value()).isEqualTo(503); + assertThat(response.getBody().code()).isEqualTo("DB_POOL_EXHAUSTED"); + assertThat(registry.get("application_failure_total") + .tag("reason", "db_pool_exhausted") + .counter() + .count()) + .isEqualTo(1); + } + + @Test + @DisplayName("DB 연결 SQLState 08 → 503 DB_UNAVAILABLE") + void dbUnavailable() { + DataAccessResourceFailureException failure = + new DataAccessResourceFailureException( + "database down", + new SQLException("connection refused", "08006")); + + ResponseEntity response = handler.databaseResourceFailure(failure); + + assertThat(response.getStatusCode().value()).isEqualTo(503); + assertThat(response.getBody().code()).isEqualTo("DB_UNAVAILABLE"); + } + @Test @DisplayName("system invariant → 500 + invariant metric") void invariant() { diff --git a/src/test/java/com/study/course_registration/web/error/SpringMvcErrorContractTest.java b/src/test/java/com/study/course_registration/web/error/SpringMvcErrorContractTest.java new file mode 100644 index 0000000..2b11830 --- /dev/null +++ b/src/test/java/com/study/course_registration/web/error/SpringMvcErrorContractTest.java @@ -0,0 +1,57 @@ +package com.study.course_registration.web.error; + +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc; +import org.springframework.http.MediaType; +import org.springframework.test.web.servlet.MockMvc; + +import com.study.course_registration.support.CourseIntegrationTest; + +@CourseIntegrationTest +@AutoConfigureMockMvc +@DisplayName("Spring MVC 표준 오류 계약") +class SpringMvcErrorContractTest { + @Autowired MockMvc mockMvc; + + @Test + @DisplayName("없는 API → 404 NOT_FOUND") + void unknownRoute404() throws Exception { + mockMvc.perform(get("/api/v1/not-found")) + .andExpect(status().isNotFound()) + .andExpect(jsonPath("$.code").value("NOT_FOUND")); + } + + @Test + @DisplayName("지원하지 않는 메서드 → 405 METHOD_NOT_ALLOWED") + void unsupportedMethod405() throws Exception { + mockMvc.perform(put("/api/v1/lessons")) + .andExpect(status().isMethodNotAllowed()) + .andExpect(jsonPath("$.code").value("METHOD_NOT_ALLOWED")); + } + + @Test + @DisplayName("지원하지 않는 Content-Type → 415 UNSUPPORTED_MEDIA_TYPE") + void unsupportedMediaType415() throws Exception { + mockMvc.perform(post("/api/v1/users/user/registrations") + .contentType(MediaType.TEXT_PLAIN) + .content("{\"lessonId\":\"lesson\"}")) + .andExpect(status().isUnsupportedMediaType()) + .andExpect(jsonPath("$.code").value("UNSUPPORTED_MEDIA_TYPE")); + } + + @Test + @DisplayName("요청 파라미터 타입 불일치 → 400 VALIDATION_ERROR") + void typeMismatch400() throws Exception { + mockMvc.perform(get("/api/v1/lessons?page=abc")) + .andExpect(status().isBadRequest()) + .andExpect(jsonPath("$.code").value("VALIDATION_ERROR")); + } +}