refactor: clean-architecture적으로 책임 분리 및 예외 및 검증 강화, 디자인패턴 적용

This commit is contained in:
donghyeon-ka
2026-09-22 18:09:00 +09:00
parent fe895b091a
commit bffc86c71d
81 changed files with 1219 additions and 751 deletions
+29 -9
View File
@@ -115,11 +115,21 @@ POST는 선택적으로 Idempotency-Key 헤더를 받습니다.
application action은 `RegisterCourseUseCase`, `CancelRegistrationUseCase`, `GetRegistrationsQuery`, `GetLessonsQuery`, `GetLessonQuery`, `CleanupIdempotencyUseCase`로 분리합니다.
수강신청 정책은 `RegistrationContext`를 입력으로 받고 `RegistrationPolicy`가 R1~R8의 관측 가능한 우선순서를 명시적인 ordered rule list로 유지합니다. Application은 Spring Data JPA repository, `@Lock`, `Page`, projection 구현을 알지 않습니다.
수강신청 정책은 `RegistrationContext`를 입력으로 받고 `RegistrationPolicy`가 R1~R8의 관측 가능한 우선순서를 명시적인 ordered rule list로 유지합니다.
이 프로젝트는 **strict boundary**를 선택합니다.
- Domain은 Spring/JPA에 의존하지 않는 plain Java다.
- Application Port는 JPA Entity를 반환하지 않고 snapshot/read model만 반환한다.
- Spring Data Repository와 JPA Entity mapping은 infrastructure 안에서 끝낸다.
- Application은 `@Lock`, `Page`, projection, `EntityManager` 같은 persistence mechanism을 알지 않는다.
- `ArchitectureTest`가 `application/domain -> entity`, `domain -> Spring`, `application -> Spring Data/JPA` 의존을 금지한다.
실패도 의미에 따라 분리합니다.
- `ApplicationFailure`: resource not found / business rejection / authorization / request validation / retryable infrastructure
- `KnownFailure`
- `ApplicationFailure`: resource not found / business rejection / authorization / request validation
- `RetryableInfrastructureFailure`: lock timeout처럼 재시도 가능한 infrastructure failure
- `SystemInvariantViolation`: 중복 활성 학기, 필수 시간표 누락 등 사용자 재시도로 해결되지 않는 invariant 위반
- HTTP status는 `RegistrationErrorCode`가 아니라 Web의 `FailureHttpMapper`가 결정
- business rejection은 ERROR stacktrace를 남기지 않고 metric으로 집계
@@ -127,14 +137,24 @@ application action은 `RegisterCourseUseCase`, `CancelRegistrationUseCase`, `Get
## Concurrency invariant
mutation 경로는 한 곳에서 아래 순서로 lock을 획득합니다.
신청 mutation은 다음 순서를 유지합니다.
User FOR UPDATE
-> Lesson FOR UPDATE
-> R1~R8 검증
-> INSERT / cancel
RegistrationExecutionScope 확보
-> Infrastructure에서 User FOR UPDATE
-> Infrastructure에서 Lesson FOR UPDATE
-> Idempotency 판정
-> replay면 즉시 반환
-> 신규 요청이면 RegistrationContext 조회
-> active registrations
-> schedules
-> capacity count
-> R1~R8 검증
-> RegistrationWindowGuard 재검증
-> INSERT
`JpaRegistrationContextLoader`가 User → Lesson 순서로 실제 row lock을 획득합니다. 해당 context loader 테스트가 순서를 직접 검증하고, `ArchitectureTest`는 application/domain/web이 persistence 경계를 우회하지 못하도록 고정합니다.
`RegistrationExecutionScopeLoader.open()`은 업무 용어만 노출하고 실제 `FOR UPDATE`는 `JpaRegistrationExecutionScopeLoader` 내부에 숨깁니다. replay 요청은 User/Lesson 직렬화와 idempotency lookup 뒤에 바로 끝나며 active/schedule/count query를 수행하지 않습니다.
취소도 Application에서는 `CancellationContextLoader.load()`만 호출하고, User → Lesson lock 순서는 `JpaCancellationContextLoader` 내부 책임입니다.
## Master data policy
@@ -219,7 +239,7 @@ fixture는 support/fixture에 모읍니다.
- 동일 학생 시간표 경쟁
- 동일 학생 동일 강의 경쟁
- Seeder 재실행
- context loader의 User → Lesson 락 순서 / architecture rule
- execution scope loader의 User → Lesson 직렬화 순서 / strict architecture rule
./gradlew test
./gradlew jacocoTestReport
+16 -7
View File
@@ -295,7 +295,7 @@ R1은 `registrationEndAt` 정각까지 포함한다. 따라서 `now.isAfter(regi
### 5.5 구현 메모
- application은 `RegistrationContextLoader` port만 알고, `JpaRegistrationContextLoader`가 실제 User → Lesson 락 순서와 JPA 조회 전략을 구현한다
- application은 `RegistrationExecutionScopeLoader.open()`으로 실행 범위를 확보한다. 실제 User → Lesson `FOR UPDATE`는 `JpaRegistrationExecutionScopeLoader`가 구현하고 application contract에는 lock 용어를 노출하지 않는다
- Spring Data Repository의 `@Lock(LockModeType.PESSIMISTIC_WRITE)`는 infrastructure adapter 뒤에서만 사용한다
- `RegisterCourseUseCase`/`CancelRegistrationUseCase` mutation 전체에 `@Transactional`을 건다. 락은 커밋 시점에 풀린다
- H2와 PostgreSQL 모두 `FOR UPDATE`를 지원하지만 **락 타임아웃 적용 방식은 같지 않다**
@@ -646,17 +646,26 @@ User 락은 R5~R7 직렬화와 일관된 판정을 담당하고, DB UNIQUE는 R4
| `web/error` | `ApiExceptionHandler`, `FailureHttpMapper`, `FailureMetrics` | failure → HTTP/log/metric 표현 |
| `application/registration` | `RegisterCourseUseCase`, `CancelRegistrationUseCase`, `GetRegistrationsQuery` | transaction과 업무 흐름 orchestration |
| `application/lesson` | `GetLessonsQuery`, `GetLessonQuery` | 강의 조회 UseCase |
| `application/idempotency` | `IdempotencyPolicy`, `CleanupIdempotencyUseCase` | replay/TTL/cleanup 의미 |
| `application/*/port` | `RegistrationContextLoader`, `RegistrationReader`, `RegistrationWriter`, `LessonQueryPort`, `SemesterQueryPort`, `IdempotencyPort` | application이 요구하는 persistence capability |
| `domain/registration` | `RegistrationContext`, `RegistrationPolicy`, `RegistrationRule` | decision data와 ordered policy |
| `application/idempotency` | `IdempotencyCoordinator`, `CleanupIdempotencyUseCase` | normalize/TTL/replay 판정/record orchestration |
| `application/*/port` | `RegistrationExecutionScopeLoader`, `RegistrationDecisionContextLoader`, `CancellationContextLoader`, `RegistrationReader`, `RegistrationWriter`, `LessonQueryPort`, `SemesterQueryPort`, `IdempotencyPort` | application이 요구하는 업무 capability |
| `domain/registration` | `RegistrationContext`, snapshot, `RegistrationPolicy`, `RegistrationWindowGuard` | persistence와 독립된 신청 decision model/policy |
| `domain/registration/rule` | R1~R8 rule | 한 규칙당 한 변경 이유 |
| `domain/schedule` | `LessonSchedulePolicy`, `ScheduleConflictChecker` | 시간표 invariant/충돌 |
| `infrastructure/persistence` | `Jpa*Adapter`, `JpaRegistrationContextLoader` | Spring Data/JPA query, lock, pagination, projection |
| `domain/schedule` | `ScheduleSlot`, `LessonSchedulePolicy`, `ScheduleConflictChecker` | persistence와 독립된 시간표 invariant/충돌 |
| `infrastructure/persistence` | `Jpa*Adapter`, `JpaRegistrationExecutionScopeLoader`, `JpaRegistrationDecisionContextLoader`, `JpaCancellationContextLoader`, `JpaSnapshotMapper` | JPA Entity ↔ snapshot/read model 변환, query, lock, pagination |
| `infrastructure/scheduling` | `IdempotencyRetentionJob` | scheduler adapter |
| `failure` | `ApplicationFailure`, `SystemInvariantViolation` | HTTP와 독립된 실패 의미 |
| `infrastructure/persistence/repository` | Spring Data repository | JPA adapter가 사용하는 persistence mechanism |
의존 방향은 `web -> application -> domain/port <- infrastructure`를 유지한다. `ArchitectureTest`가 application의 raw repository/Spring Data JPA 접근, domain의 상위 계층 접근, web의 infrastructure 직접 접근을 금지한다.
의존 방향은 `web -> application -> domain/port <- infrastructure`를 유지한다.
아키텍처 정책은 **strict clean boundary**로 고정한다.
- Application/Domain에는 JPA Entity가 전달되지 않는다.
- Port는 snapshot/read model/command만 사용한다.
- Domain은 Spring Framework/JPA annotation에 의존하지 않는다.
- Spring wiring은 `config/DomainPolicyConfig`에서 수행한다.
- Query는 `LessonListView`, `LessonDetailView`, `ActiveRegistrationView` 같은 read model을 infrastructure에서 조립한다.
- `ArchitectureTest`가 위 의존 규칙을 자동 검증한다.
---
@@ -1,19 +0,0 @@
package com.study.course_registration.application.common;
import java.time.DayOfWeek;
import java.time.LocalTime;
import com.study.course_registration.entity.LessonSchedule;
public record ScheduleSlot(
DayOfWeek dayOfWeek,
LocalTime startTime,
LocalTime endTime) {
public static ScheduleSlot from(LessonSchedule schedule) {
return new ScheduleSlot(
schedule.getDayOfWeek(),
schedule.getStartTime(),
schedule.getEndTime());
}
}
@@ -7,21 +7,21 @@ 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.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.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.failure.RequestValidationFailure;
@Component
public class IdempotencyPolicy {
public class IdempotencyCoordinator {
private final IdempotencyPort idempotencies;
private final long ttlSeconds;
public IdempotencyPolicy(
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,13 +33,13 @@ public class IdempotencyPolicy {
}
idempotencies.deleteExpiredKey(userId, key, now);
Optional<RegistrationIdempotency> previous = idempotencies.findActive(userId, key, now);
Optional<ReplayRecord> previous = idempotencies.findActive(userId, key, now);
if (previous.isEmpty()) {
return Decision.newRequest(key);
}
RegistrationIdempotency stored = previous.get();
if (!stored.getLesson().getId().equals(lessonId)) {
ReplayRecord stored = previous.get();
if (!stored.lessonId().equals(lessonId)) {
throw BusinessRejection.idempotencyKeyReused();
}
return Decision.replay(key, stored);
@@ -47,18 +47,18 @@ public class IdempotencyPolicy {
public void record(
Decision decision,
User user,
Lesson lesson,
UserLesson registration,
RegistrationContext context,
RegistrationRecord registration,
int totalCredits,
Instant now) {
if (decision.key() == null || decision.replay().isPresent()) {
return;
}
idempotencies.save(new RegistrationIdempotency(
user,
lesson,
registration,
idempotencies.save(new SaveCommand(
context.user().id(),
context.lesson().id(),
registration.registrationId(),
decision.key(),
totalCredits,
now.plusSeconds(ttlSeconds)));
@@ -75,7 +75,10 @@ public class IdempotencyPolicy {
return normalized;
}
public record Decision(String key, Optional<RegistrationIdempotency> replay) {
public record Decision(
String key,
Optional<ReplayRecord> replay) {
static Decision withoutKey() {
return new Decision(null, Optional.empty());
}
@@ -84,7 +87,7 @@ public class IdempotencyPolicy {
return new Decision(key, Optional.empty());
}
static Decision replay(String key, RegistrationIdempotency stored) {
static Decision replay(String key, ReplayRecord stored) {
return new Decision(key, Optional.of(stored));
}
}
@@ -3,14 +3,32 @@ package com.study.course_registration.application.idempotency.port;
import java.time.Instant;
import java.util.Optional;
import com.study.course_registration.entity.RegistrationIdempotency;
public interface IdempotencyPort {
Optional<RegistrationIdempotency> findActive(String userId, String key, Instant now);
Optional<ReplayRecord> findActive(String userId, String key, Instant now);
void deleteExpiredKey(String userId, String key, Instant now);
void deleteExpired(Instant now);
RegistrationIdempotency save(RegistrationIdempotency idempotency);
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) {
}
}
@@ -1,14 +1,10 @@
package com.study.course_registration.application.lesson;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.study.course_registration.application.common.ScheduleSlot;
import com.study.course_registration.application.lesson.port.LessonQueryPort;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.application.lesson.port.LessonQueryPort.LessonDetailView;
import com.study.course_registration.failure.ResourceNotFound;
@Service
@@ -21,31 +17,24 @@ public class GetLessonQuery {
}
public LessonDetailResult execute(String lessonId) {
Lesson lesson = lessons.findDetailed(lessonId)
LessonDetailView lesson = lessons.findDetailed(lessonId)
.orElseThrow(ResourceNotFound::lesson);
List<ScheduleSlot> schedules = lessons.findSchedules(List.of(lessonId)).stream()
.map(ScheduleSlot::from)
.toList();
Map<String, Long> counts = lessons.countActiveEnrollments(List.of(lessonId));
long enrolledCount = counts.getOrDefault(lessonId, 0L);
return new LessonDetailResult(
lesson.getId(),
lesson.getName(),
lesson.getSubject().getCode(),
lesson.getSubject().getName(),
lesson.getSubject().getDescription(),
lesson.getSubject().getCredit(),
lesson.getProfessor().getName(),
lesson.getSemester().getName(),
lesson.getCapacity(),
enrolledCount,
lesson.getMinGrade(),
lesson.getAllowedRole(),
lesson.getSemester().getRegistrationStartAt(),
lesson.getSemester().getRegistrationEndAt(),
schedules);
lesson.lessonId(),
lesson.lessonName(),
lesson.subjectCode(),
lesson.subjectName(),
lesson.subjectDescription(),
lesson.credit(),
lesson.professorName(),
lesson.semesterName(),
lesson.capacity(),
lesson.enrolledCount(),
lesson.minGrade(),
lesson.allowedRole(),
lesson.registrationStartAt(),
lesson.registrationEndAt(),
lesson.schedules());
}
}
@@ -1,21 +1,16 @@
package com.study.course_registration.application.lesson;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.study.course_registration.application.common.ScheduleSlot;
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.semester.SemesterSelectionPolicy;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.application.semester.SemesterSnapshot;
@Service
@Transactional(readOnly = true)
@@ -31,33 +26,11 @@ public class GetLessonsQuery {
}
public LessonListResult execute(String semesterId, String subjectId, int page, int size) {
Semester semester = semesterSelectionPolicy.resolve(semesterId);
LessonPage lessonPage = lessons.findPage(semester.getId(), subjectId, page, size);
List<String> lessonIds = lessonPage.lessons().stream()
.map(Lesson::getId)
.toList();
Map<String, List<LessonSchedule>> schedules = groupSchedules(
lessonIds.isEmpty() ? List.of() : lessons.findSchedules(lessonIds));
Map<String, Long> counts = lessonIds.isEmpty()
? Map.of()
: lessons.countActiveEnrollments(lessonIds);
SemesterSnapshot semester = semesterSelectionPolicy.resolve(semesterId);
LessonPage lessonPage = lessons.findPage(semester.id(), subjectId, page, size);
List<LessonItemResult> items = lessonPage.lessons().stream()
.map(lesson -> new LessonItemResult(
lesson.getId(),
lesson.getName(),
lesson.getSubject().getCode(),
lesson.getSubject().getName(),
lesson.getSubject().getCredit(),
lesson.getProfessor().getName(),
lesson.getCapacity(),
counts.getOrDefault(lesson.getId(), 0L),
lesson.getMinGrade(),
lesson.getAllowedRole(),
schedules.getOrDefault(lesson.getId(), List.of()).stream()
.map(ScheduleSlot::from)
.toList()))
.map(GetLessonsQuery::toItem)
.toList();
return new LessonListResult(
@@ -67,10 +40,18 @@ public class GetLessonsQuery {
items);
}
private static Map<String, List<LessonSchedule>> groupSchedules(List<LessonSchedule> schedules) {
return schedules.stream().collect(Collectors.groupingBy(
schedule -> schedule.getLesson().getId(),
LinkedHashMap::new,
Collectors.toList()));
private static LessonItemResult toItem(LessonListView lesson) {
return new LessonItemResult(
lesson.lessonId(),
lesson.lessonName(),
lesson.subjectCode(),
lesson.subjectName(),
lesson.credit(),
lesson.professorName(),
lesson.capacity(),
lesson.enrolledCount(),
lesson.minGrade(),
lesson.allowedRole(),
lesson.schedules());
}
}
@@ -3,7 +3,7 @@ package com.study.course_registration.application.lesson;
import java.time.Instant;
import java.util.List;
import com.study.course_registration.application.common.ScheduleSlot;
import com.study.course_registration.domain.schedule.ScheduleSlot;
import com.study.course_registration.enums.UserRole;
public record LessonDetailResult(
@@ -2,7 +2,7 @@ package com.study.course_registration.application.lesson;
import java.util.List;
import com.study.course_registration.application.common.ScheduleSlot;
import com.study.course_registration.domain.schedule.ScheduleSlot;
import com.study.course_registration.enums.UserRole;
public record LessonListResult(
@@ -1,22 +1,51 @@
package com.study.course_registration.application.lesson.port;
import java.util.Collection;
import java.time.Instant;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.domain.schedule.ScheduleSlot;
import com.study.course_registration.enums.UserRole;
public interface LessonQueryPort {
LessonPage findPage(String semesterId, String subjectId, int page, int size);
Optional<Lesson> findDetailed(String lessonId);
Optional<LessonDetailView> findDetailed(String lessonId);
List<LessonSchedule> findSchedules(Collection<String> lessonIds);
record LessonPage(
List<LessonListView> lessons,
long totalElements) {
}
Map<String, Long> countActiveEnrollments(Collection<String> lessonIds);
record LessonListView(
String lessonId,
String lessonName,
String subjectCode,
String subjectName,
int credit,
String professorName,
int capacity,
long enrolledCount,
Long minGrade,
UserRole allowedRole,
List<ScheduleSlot> schedules) {
}
record LessonPage(List<Lesson> lessons, long totalElements) {
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<ScheduleSlot> schedules) {
}
}
@@ -6,55 +6,43 @@ import java.time.Instant;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.study.course_registration.application.registration.port.RegistrationContextLoader;
import com.study.course_registration.application.registration.port.RegistrationContextLoader.LockedRegistration;
import com.study.course_registration.application.registration.port.RegistrationReader;
import com.study.course_registration.application.registration.port.CancellationContextLoader;
import com.study.course_registration.application.registration.port.RegistrationWriter;
import com.study.course_registration.application.registration.port.RegistrationReader.RegistrationTarget;
import com.study.course_registration.domain.registration.rule.RegistrationPeriodRule;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.domain.registration.CancellationContext;
import com.study.course_registration.domain.registration.RegistrationWindowGuard;
import com.study.course_registration.failure.AuthorizationFailure;
import com.study.course_registration.failure.ResourceNotFound;
@Service
public class CancelRegistrationUseCase {
private final Clock clock;
private final RegistrationReader registrations;
private final RegistrationWriter registrationWriter;
private final RegistrationContextLoader contextLoader;
private final RegistrationPeriodRule periodRule;
private final CancellationContextLoader contexts;
private final RegistrationWriter registrations;
private final RegistrationWindowGuard registrationWindowGuard;
public CancelRegistrationUseCase(
Clock clock,
RegistrationReader registrations,
RegistrationWriter registrationWriter,
RegistrationContextLoader contextLoader,
RegistrationPeriodRule periodRule) {
CancellationContextLoader contexts,
RegistrationWriter registrations,
RegistrationWindowGuard registrationWindowGuard) {
this.clock = clock;
this.contexts = contexts;
this.registrations = registrations;
this.registrationWriter = registrationWriter;
this.contextLoader = contextLoader;
this.periodRule = periodRule;
this.registrationWindowGuard = registrationWindowGuard;
}
@Transactional
public void execute(String userId, String registrationId) {
RegistrationTarget target = registrations.findTarget(registrationId)
.orElseThrow(ResourceNotFound::registration);
if (!target.userId().equals(userId)) {
CancellationContext context = contexts.load(registrationId);
if (!context.ownerUserId().equals(userId)) {
throw AuthorizationFailure.registrationForbidden();
}
LockedRegistration locked = contextLoader.lockForUpdate(userId, target.lessonId());
UserLesson registration = registrations.findRegistration(registrationId)
.orElseThrow(ResourceNotFound::registration);
if (registration.isCanceled()) {
if (context.canceled()) {
return;
}
Instant now = clock.instant();
periodRule.validate(locked.lesson(), now);
registration.cancel(now);
registrationWriter.save(registration);
registrationWindowGuard.verify(context.lesson(), now);
registrations.cancel(context.registrationId(), now);
}
}
@@ -1,23 +1,15 @@
package com.study.course_registration.application.registration;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.study.course_registration.application.common.ScheduleSlot;
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.semester.SemesterSelectionPolicy;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.application.semester.SemesterSnapshot;
import com.study.course_registration.failure.ResourceNotFound;
@Service
@@ -38,57 +30,37 @@ public class GetRegistrationsQuery {
throw ResourceNotFound.user();
}
Semester semester = semesterSelectionPolicy.resolve(semesterId);
List<UserLesson> active = registrations.findActive(userId, semester.getId());
Set<String> lessonIds = active.stream()
.map(UserLesson::getLesson)
.map(Lesson::getId)
.collect(Collectors.toCollection(LinkedHashSet::new));
Map<String, List<LessonSchedule>> schedules = groupSchedules(
lessonIds.isEmpty() ? List.of() : registrations.findSchedules(lessonIds));
SemesterSnapshot semester = semesterSelectionPolicy.resolve(semesterId);
List<ActiveRegistrationView> active =
registrations.findActive(userId, semester.id());
List<RegistrationItemResult> items = active.stream()
.map(registration -> toItem(registration, schedules))
.map(GetRegistrationsQuery::toItem)
.toList();
int totalCredits = active.stream()
.map(UserLesson::getLesson)
.map(Lesson::getSubject)
.mapToInt(subject -> subject.getCredit())
.mapToInt(ActiveRegistrationView::credit)
.sum();
return new RegistrationListResult(
userId,
semester.getId(),
semester.getName(),
semester.id(),
semester.name(),
totalCredits,
semester.getMaxCredits(),
semester.maxCredits(),
items);
}
private static RegistrationItemResult toItem(
UserLesson registration,
Map<String, List<LessonSchedule>> schedules) {
Lesson lesson = registration.getLesson();
private static RegistrationItemResult toItem(ActiveRegistrationView registration) {
return new RegistrationItemResult(
registration.getId(),
lesson.getId(),
lesson.getName(),
lesson.getSubject().getCode(),
lesson.getSubject().getName(),
lesson.getSubject().getCredit(),
lesson.getProfessor().getName(),
schedules.getOrDefault(lesson.getId(), List.of()).stream()
.map(ScheduleSlot::from)
.toList(),
registration.getCreatedAt());
}
private static Map<String, List<LessonSchedule>> groupSchedules(List<LessonSchedule> schedules) {
return schedules.stream().collect(Collectors.groupingBy(
schedule -> schedule.getLesson().getId(),
LinkedHashMap::new,
Collectors.toList()));
registration.registrationId(),
registration.lessonId(),
registration.lessonName(),
registration.subjectCode(),
registration.subjectName(),
registration.credit(),
registration.professorName(),
registration.schedules(),
registration.registeredAt());
}
}
@@ -6,85 +6,98 @@ import java.time.Instant;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.study.course_registration.application.idempotency.IdempotencyPolicy;
import com.study.course_registration.application.idempotency.IdempotencyPolicy.Decision;
import com.study.course_registration.application.registration.port.RegistrationContextLoader;
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.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.domain.registration.RegistrationExecutionScope;
import com.study.course_registration.domain.registration.RegistrationPolicy;
import com.study.course_registration.domain.registration.rule.RegistrationPeriodRule;
import com.study.course_registration.entity.RegistrationIdempotency;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.domain.registration.RegistrationWindowGuard;
@Service
public class RegisterCourseUseCase {
private final Clock clock;
private final RegistrationContextLoader contextLoader;
private final RegistrationExecutionScopeLoader executionScopes;
private final RegistrationDecisionContextLoader decisionContexts;
private final RegistrationWriter registrations;
private final RegistrationPolicy registrationPolicy;
private final RegistrationPeriodRule periodRule;
private final IdempotencyPolicy idempotencyPolicy;
private final RegistrationResultAssembler resultAssembler;
private final RegistrationWindowGuard registrationWindowGuard;
private final IdempotencyCoordinator idempotency;
public RegisterCourseUseCase(
Clock clock,
RegistrationContextLoader contextLoader,
RegistrationExecutionScopeLoader executionScopes,
RegistrationDecisionContextLoader decisionContexts,
RegistrationWriter registrations,
RegistrationPolicy registrationPolicy,
RegistrationPeriodRule periodRule,
IdempotencyPolicy idempotencyPolicy,
RegistrationResultAssembler resultAssembler) {
RegistrationWindowGuard registrationWindowGuard,
IdempotencyCoordinator idempotency) {
this.clock = clock;
this.contextLoader = contextLoader;
this.executionScopes = executionScopes;
this.decisionContexts = decisionContexts;
this.registrations = registrations;
this.registrationPolicy = registrationPolicy;
this.periodRule = periodRule;
this.idempotencyPolicy = idempotencyPolicy;
this.resultAssembler = resultAssembler;
this.registrationWindowGuard = registrationWindowGuard;
this.idempotency = idempotency;
}
@Transactional
public RegistrationResult execute(RegisterCourseCommand command) {
Instant requestTime = clock.instant();
RegistrationContext context = contextLoader.loadForRegistration(
command.userId(),
command.lessonId(),
requestTime);
Decision decision = idempotencyPolicy.evaluate(
command.userId(),
command.lessonId(),
RegistrationExecutionScope scope =
executionScopes.open(command.userId(), command.lessonId());
Decision decision = idempotency.evaluate(
scope.userId(),
scope.lessonId(),
command.idempotencyKey(),
requestTime);
if (decision.replay().isPresent()) {
RegistrationIdempotency stored = decision.replay().orElseThrow();
return resultAssembler.assemble(
stored.getRegistration(),
stored.getUser(),
stored.getLesson(),
stored.getTotalCredits());
return replay(decision.replay().orElseThrow());
}
RegistrationContext context = decisionContexts.load(scope, requestTime);
registrationPolicy.validate(context);
periodRule.validate(context.lesson(), clock.instant());
registrationWindowGuard.verify(context.lesson(), clock.instant());
int totalCredits = context.totalCreditsAfter();
UserLesson registration = registrations.save(
new UserLesson(context.user(), context.lesson()));
RegistrationRecord registration =
registrations.create(scope.userId(), scope.lessonId());
idempotencyPolicy.record(
idempotency.record(
decision,
context.user(),
context.lesson(),
context,
registration,
totalCredits,
requestTime);
return resultAssembler.assemble(
registration,
context.user(),
context.lesson(),
return new RegistrationResult(
registration.registrationId(),
context.user().id(),
context.lesson().id(),
context.lesson().name(),
context.lesson().subjectCode(),
context.lesson().subjectCredit(),
registration.registeredAt(),
totalCredits);
}
private static RegistrationResult replay(ReplayRecord stored) {
return new RegistrationResult(
stored.registrationId(),
stored.userId(),
stored.lessonId(),
stored.lessonName(),
stored.subjectCode(),
stored.credit(),
stored.registeredAt(),
stored.totalCredits());
}
}
@@ -3,7 +3,7 @@ package com.study.course_registration.application.registration;
import java.time.Instant;
import java.util.List;
import com.study.course_registration.application.common.ScheduleSlot;
import com.study.course_registration.domain.schedule.ScheduleSlot;
public record RegistrationListResult(
String userId,
@@ -1,26 +0,0 @@
package com.study.course_registration.application.registration;
import org.springframework.stereotype.Component;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.User;
import com.study.course_registration.entity.UserLesson;
@Component
public class RegistrationResultAssembler {
public RegistrationResult assemble(
UserLesson registration,
User user,
Lesson lesson,
int totalCredits) {
return new RegistrationResult(
registration.getId(),
user.getId(),
lesson.getId(),
lesson.getName(),
lesson.getSubject().getCode(),
lesson.getSubject().getCredit(),
registration.getCreatedAt(),
totalCredits);
}
}
@@ -0,0 +1,7 @@
package com.study.course_registration.application.registration.port;
import com.study.course_registration.domain.registration.CancellationContext;
public interface CancellationContextLoader {
CancellationContext load(String registrationId);
}
@@ -1,16 +0,0 @@
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.entity.Lesson;
import com.study.course_registration.entity.User;
public interface RegistrationContextLoader {
RegistrationContext loadForRegistration(String userId, String lessonId, Instant now);
LockedRegistration lockForUpdate(String userId, String lessonId);
record LockedRegistration(User user, Lesson lesson) {
}
}
@@ -0,0 +1,10 @@
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.RegistrationExecutionScope;
public interface RegistrationDecisionContextLoader {
RegistrationContext load(RegistrationExecutionScope scope, Instant now);
}
@@ -0,0 +1,7 @@
package com.study.course_registration.application.registration.port;
import com.study.course_registration.domain.registration.RegistrationExecutionScope;
public interface RegistrationExecutionScopeLoader {
RegistrationExecutionScope open(String userId, String lessonId);
}
@@ -1,23 +1,24 @@
package com.study.course_registration.application.registration.port;
import java.util.Collection;
import java.time.Instant;
import java.util.List;
import java.util.Optional;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.domain.schedule.ScheduleSlot;
public interface RegistrationReader {
boolean userExists(String userId);
Optional<RegistrationTarget> findTarget(String registrationId);
List<ActiveRegistrationView> findActive(String userId, String semesterId);
Optional<UserLesson> findRegistration(String registrationId);
List<UserLesson> findActive(String userId, String semesterId);
List<LessonSchedule> findSchedules(Collection<String> lessonIds);
record RegistrationTarget(String userId, String lessonId) {
record ActiveRegistrationView(
String registrationId,
String lessonId,
String lessonName,
String subjectCode,
String subjectName,
int credit,
String professorName,
List<ScheduleSlot> schedules,
Instant registeredAt) {
}
}
@@ -1,7 +1,14 @@
package com.study.course_registration.application.registration.port;
import com.study.course_registration.entity.UserLesson;
import java.time.Instant;
public interface RegistrationWriter {
UserLesson save(UserLesson registration);
RegistrationRecord create(String userId, String lessonId);
void cancel(String registrationId, Instant canceledAt);
record RegistrationRecord(
String registrationId,
Instant registeredAt) {
}
}
@@ -8,7 +8,6 @@ import java.util.List;
import org.springframework.stereotype.Component;
import com.study.course_registration.application.semester.port.SemesterQueryPort;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.failure.ResourceNotFound;
import com.study.course_registration.failure.SystemInvariantViolation;
@@ -22,13 +21,13 @@ public class SemesterSelectionPolicy {
this.semesters = semesters;
}
public Semester resolve(String semesterId) {
public SemesterSnapshot resolve(String semesterId) {
if (semesterId != null && !semesterId.isBlank()) {
return semesters.findById(semesterId).orElseThrow(ResourceNotFound::semester);
}
Instant now = clock.instant();
List<Semester> registrationSemesters = semesters.findRegistrationSemesters(now);
List<SemesterSnapshot> registrationSemesters = semesters.findRegistrationSemesters(now);
if (registrationSemesters.size() > 1) {
throw SystemInvariantViolation.multipleRegistrationSemesters();
}
@@ -37,7 +36,7 @@ public class SemesterSelectionPolicy {
}
LocalDate today = LocalDate.now(clock);
List<Semester> academicSemesters = semesters.findAcademicSemesters(today);
List<SemesterSnapshot> academicSemesters = semesters.findAcademicSemesters(today);
if (academicSemesters.size() > 1) {
throw SystemInvariantViolation.multipleAcademicSemesters();
}
@@ -0,0 +1,14 @@
package com.study.course_registration.application.semester;
import java.time.Instant;
import java.time.LocalDate;
public record SemesterSnapshot(
String id,
String name,
LocalDate startDate,
LocalDate endDate,
Instant registrationStartAt,
Instant registrationEndAt,
int maxCredits) {
}
@@ -5,12 +5,12 @@ import java.time.LocalDate;
import java.util.List;
import java.util.Optional;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.application.semester.SemesterSnapshot;
public interface SemesterQueryPort {
Optional<Semester> findById(String semesterId);
Optional<SemesterSnapshot> findById(String semesterId);
List<Semester> findRegistrationSemesters(Instant now);
List<SemesterSnapshot> findRegistrationSemesters(Instant now);
List<Semester> findAcademicSemesters(LocalDate today);
List<SemesterSnapshot> findAcademicSemesters(LocalDate today);
}
@@ -0,0 +1,50 @@
package com.study.course_registration.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.study.course_registration.domain.registration.RegistrationPolicy;
import com.study.course_registration.domain.registration.RegistrationWindowGuard;
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;
import com.study.course_registration.domain.schedule.LessonSchedulePolicy;
import com.study.course_registration.domain.schedule.ScheduleConflictChecker;
@Configuration
public class DomainPolicyConfig {
@Bean
ScheduleConflictChecker scheduleConflictChecker() {
return new ScheduleConflictChecker();
}
@Bean
LessonSchedulePolicy lessonSchedulePolicy(ScheduleConflictChecker checker) {
return new LessonSchedulePolicy(checker);
}
@Bean
RegistrationWindowGuard registrationWindowGuard() {
return new RegistrationWindowGuard();
}
@Bean
RegistrationPolicy registrationPolicy(ScheduleConflictChecker checker) {
return new RegistrationPolicy(
new RegistrationPeriodRule(),
new GradeEligibilityRule(),
new RoleEligibilityRule(),
new AlreadyRegisteredRule(),
new DuplicateSubjectRule(),
new ScheduleAvailabilityRule(),
new ScheduleConflictRule(checker),
new CreditLimitRule(),
new CapacityRule());
}
}
@@ -0,0 +1,8 @@
package com.study.course_registration.domain.registration;
public record ActiveRegistrationSnapshot(
String registrationId,
String lessonId,
String subjectId,
int credit) {
}
@@ -0,0 +1,8 @@
package com.study.course_registration.domain.registration;
public record CancellationContext(
String ownerUserId,
String registrationId,
LessonPolicySnapshot lesson,
boolean canceled) {
}
@@ -0,0 +1,20 @@
package com.study.course_registration.domain.registration;
import java.time.Instant;
import com.study.course_registration.enums.UserRole;
public record LessonPolicySnapshot(
String id,
String name,
String subjectId,
String subjectCode,
int subjectCredit,
String semesterId,
Instant registrationStartAt,
Instant registrationEndAt,
int maxCredits,
int capacity,
Long minGrade,
UserRole allowedRole) {
}
@@ -4,36 +4,31 @@ import java.time.Instant;
import java.util.List;
import java.util.Map;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.entity.User;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.domain.schedule.ScheduleSlot;
public record RegistrationContext(
User user,
Lesson lesson,
List<UserLesson> activeRegistrations,
Map<String, List<LessonSchedule>> schedulesByLessonId,
UserProfile user,
LessonPolicySnapshot lesson,
List<ActiveRegistrationSnapshot> activeRegistrations,
Map<String, List<ScheduleSlot>> schedulesByLessonId,
long enrolledCount,
Instant now) {
public List<LessonSchedule> candidateSchedules() {
return schedulesByLessonId.getOrDefault(lesson.getId(), List.of());
public List<ScheduleSlot> candidateSchedules() {
return schedulesByLessonId.getOrDefault(lesson.id(), List.of());
}
public List<LessonSchedule> schedulesOf(UserLesson registration) {
return schedulesByLessonId.getOrDefault(registration.getLesson().getId(), List.of());
public List<ScheduleSlot> schedulesOf(ActiveRegistrationSnapshot registration) {
return schedulesByLessonId.getOrDefault(registration.lessonId(), List.of());
}
public int currentCredits() {
return activeRegistrations.stream()
.map(UserLesson::getLesson)
.map(Lesson::getSubject)
.mapToInt(subject -> subject.getCredit())
.mapToInt(ActiveRegistrationSnapshot::credit)
.sum();
}
public int totalCreditsAfter() {
return currentCredits() + lesson.getSubject().getCredit();
return currentCredits() + lesson.subjectCredit();
}
}
@@ -0,0 +1,6 @@
package com.study.course_registration.domain.registration;
public record RegistrationExecutionScope(
String userId,
String lessonId) {
}
@@ -2,8 +2,6 @@ package com.study.course_registration.domain.registration;
import java.util.List;
import org.springframework.stereotype.Component;
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;
@@ -14,8 +12,7 @@ import com.study.course_registration.domain.registration.rule.RoleEligibilityRul
import com.study.course_registration.domain.registration.rule.ScheduleAvailabilityRule;
import com.study.course_registration.domain.registration.rule.ScheduleConflictRule;
@Component
public class RegistrationPolicy {
public final class RegistrationPolicy {
private final List<RegistrationRule> orderedRules;
public RegistrationPolicy(
@@ -0,0 +1,14 @@
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();
}
}
}
@@ -0,0 +1,9 @@
package com.study.course_registration.domain.registration;
import com.study.course_registration.enums.UserRole;
public record UserProfile(
String id,
long grade,
UserRole role) {
}
@@ -1,17 +1,14 @@
package com.study.course_registration.domain.registration.rule;
import org.springframework.stereotype.Component;
import com.study.course_registration.domain.registration.RegistrationContext;
import com.study.course_registration.domain.registration.RegistrationRule;
import com.study.course_registration.failure.BusinessRejection;
@Component
public class AlreadyRegisteredRule implements RegistrationRule {
public final class AlreadyRegisteredRule implements RegistrationRule {
@Override
public void validate(RegistrationContext context) {
boolean duplicate = context.activeRegistrations().stream()
.anyMatch(registration -> registration.getLesson().getId().equals(context.lesson().getId()));
.anyMatch(registration -> registration.lessonId().equals(context.lesson().id()));
if (duplicate) {
throw BusinessRejection.alreadyRegistered();
}
@@ -1,19 +1,16 @@
package com.study.course_registration.domain.registration.rule;
import org.springframework.stereotype.Component;
import com.study.course_registration.domain.registration.RegistrationContext;
import com.study.course_registration.domain.registration.RegistrationRule;
import com.study.course_registration.failure.BusinessRejection;
@Component
public class CapacityRule implements RegistrationRule {
public final class CapacityRule implements RegistrationRule {
@Override
public void validate(RegistrationContext context) {
if (context.enrolledCount() >= context.lesson().getCapacity()) {
if (context.enrolledCount() >= context.lesson().capacity()) {
throw BusinessRejection.capacityExceeded(
context.enrolledCount(),
context.lesson().getCapacity());
context.lesson().capacity());
}
}
}
@@ -1,18 +1,15 @@
package com.study.course_registration.domain.registration.rule;
import org.springframework.stereotype.Component;
import com.study.course_registration.domain.registration.RegistrationContext;
import com.study.course_registration.domain.registration.RegistrationRule;
import com.study.course_registration.failure.BusinessRejection;
@Component
public class CreditLimitRule implements RegistrationRule {
public final class CreditLimitRule implements RegistrationRule {
@Override
public void validate(RegistrationContext context) {
int current = context.currentCredits();
int requested = context.lesson().getSubject().getCredit();
int max = context.lesson().getSemester().getMaxCredits();
int requested = context.lesson().subjectCredit();
int max = context.lesson().maxCredits();
if (current + requested > max) {
throw BusinessRejection.creditLimitExceeded(current, requested, max);
}
@@ -1,18 +1,14 @@
package com.study.course_registration.domain.registration.rule;
import org.springframework.stereotype.Component;
import com.study.course_registration.domain.registration.RegistrationContext;
import com.study.course_registration.domain.registration.RegistrationRule;
import com.study.course_registration.failure.BusinessRejection;
@Component
public class DuplicateSubjectRule implements RegistrationRule {
public final class DuplicateSubjectRule implements RegistrationRule {
@Override
public void validate(RegistrationContext context) {
boolean duplicate = context.activeRegistrations().stream()
.anyMatch(registration -> registration.getLesson().getSubject().getId()
.equals(context.lesson().getSubject().getId()));
.anyMatch(registration -> registration.subjectId().equals(context.lesson().subjectId()));
if (duplicate) {
throw BusinessRejection.duplicateSubject();
}
@@ -1,18 +1,15 @@
package com.study.course_registration.domain.registration.rule;
import org.springframework.stereotype.Component;
import com.study.course_registration.domain.registration.RegistrationContext;
import com.study.course_registration.domain.registration.RegistrationRule;
import com.study.course_registration.failure.BusinessRejection;
@Component
public class GradeEligibilityRule implements RegistrationRule {
public final class GradeEligibilityRule implements RegistrationRule {
@Override
public void validate(RegistrationContext context) {
Long minGrade = context.lesson().getMinGrade();
if (minGrade != null && context.user().getGrade() < minGrade) {
throw BusinessRejection.notEligibleGrade(context.user().getGrade(), minGrade);
Long minGrade = context.lesson().minGrade();
if (minGrade != null && context.user().grade() < minGrade) {
throw BusinessRejection.notEligibleGrade(context.user().grade(), minGrade);
}
}
}
@@ -1,24 +1,14 @@
package com.study.course_registration.domain.registration.rule;
import java.time.Instant;
import org.springframework.stereotype.Component;
import com.study.course_registration.domain.registration.RegistrationContext;
import com.study.course_registration.domain.registration.RegistrationRule;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.failure.BusinessRejection;
@Component
public class RegistrationPeriodRule implements RegistrationRule {
public final class RegistrationPeriodRule implements RegistrationRule {
@Override
public void validate(RegistrationContext context) {
validate(context.lesson(), context.now());
}
public void validate(Lesson lesson, Instant now) {
if (now.isBefore(lesson.getSemester().getRegistrationStartAt())
|| now.isAfter(lesson.getSemester().getRegistrationEndAt())) {
if (context.now().isBefore(context.lesson().registrationStartAt())
|| context.now().isAfter(context.lesson().registrationEndAt())) {
throw BusinessRejection.registrationPeriodClosed();
}
}
@@ -1,18 +1,15 @@
package com.study.course_registration.domain.registration.rule;
import org.springframework.stereotype.Component;
import com.study.course_registration.domain.registration.RegistrationContext;
import com.study.course_registration.domain.registration.RegistrationRule;
import com.study.course_registration.failure.BusinessRejection;
@Component
public class RoleEligibilityRule implements RegistrationRule {
public final class RoleEligibilityRule implements RegistrationRule {
@Override
public void validate(RegistrationContext context) {
if (context.lesson().getAllowedRole() != null
&& context.user().getRole() != context.lesson().getAllowedRole()) {
throw BusinessRejection.notEligibleRole(context.lesson().getAllowedRole());
if (context.lesson().allowedRole() != null
&& context.user().role() != context.lesson().allowedRole()) {
throw BusinessRejection.notEligibleRole(context.lesson().allowedRole());
}
}
}
@@ -1,13 +1,10 @@
package com.study.course_registration.domain.registration.rule;
import org.springframework.stereotype.Component;
import com.study.course_registration.domain.registration.RegistrationContext;
import com.study.course_registration.domain.registration.RegistrationRule;
import com.study.course_registration.failure.SystemInvariantViolation;
@Component
public class ScheduleAvailabilityRule implements RegistrationRule {
public final class ScheduleAvailabilityRule implements RegistrationRule {
@Override
public void validate(RegistrationContext context) {
if (context.candidateSchedules().isEmpty()) {
@@ -1,16 +1,13 @@
package com.study.course_registration.domain.registration.rule;
import org.springframework.stereotype.Component;
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.entity.LessonSchedule;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.failure.BusinessRejection;
import com.study.course_registration.domain.schedule.ScheduleConflictChecker;
import com.study.course_registration.domain.schedule.ScheduleSlot;
import com.study.course_registration.failure.BusinessRejection;
@Component
public class ScheduleConflictRule implements RegistrationRule {
public final class ScheduleConflictRule implements RegistrationRule {
private final ScheduleConflictChecker conflictChecker;
public ScheduleConflictRule(ScheduleConflictChecker conflictChecker) {
@@ -19,14 +16,14 @@ public class ScheduleConflictRule implements RegistrationRule {
@Override
public void validate(RegistrationContext context) {
for (UserLesson registration : context.activeRegistrations()) {
for (LessonSchedule candidate : context.candidateSchedules()) {
for (LessonSchedule existing : context.schedulesOf(registration)) {
for (ActiveRegistrationSnapshot registration : context.activeRegistrations()) {
for (ScheduleSlot candidate : context.candidateSchedules()) {
for (ScheduleSlot existing : context.schedulesOf(registration)) {
if (conflictChecker.overlaps(candidate, existing)) {
throw BusinessRejection.scheduleConflict(
candidate.getDayOfWeek(),
candidate.getStartTime(),
candidate.getEndTime());
candidate.dayOfWeek(),
candidate.startTime(),
candidate.endTime());
}
}
}
@@ -4,26 +4,20 @@ import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.springframework.stereotype.Component;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.failure.SystemInvariantViolation;
import com.study.course_registration.domain.schedule.ScheduleConflictChecker;
@Component
public class LessonSchedulePolicy {
public final class LessonSchedulePolicy {
private final ScheduleConflictChecker conflictChecker;
public LessonSchedulePolicy(ScheduleConflictChecker conflictChecker) {
this.conflictChecker = conflictChecker;
}
public void validate(List<LessonSchedule> schedules) {
Map<Lesson, List<LessonSchedule>> byLesson = schedules.stream()
.collect(Collectors.groupingBy(LessonSchedule::getLesson));
public void validate(List<ScheduleSlot> schedules) {
Map<String, List<ScheduleSlot>> byLesson = schedules.stream()
.collect(Collectors.groupingBy(ScheduleSlot::lessonId));
for (List<LessonSchedule> lessonSchedules : byLesson.values()) {
for (List<ScheduleSlot> lessonSchedules : byLesson.values()) {
for (int left = 0; left < lessonSchedules.size(); left++) {
for (int right = left + 1; right < lessonSchedules.size(); right++) {
if (conflictChecker.overlaps(lessonSchedules.get(left), lessonSchedules.get(right))) {
@@ -1,14 +1,9 @@
package com.study.course_registration.domain.schedule;
import org.springframework.stereotype.Component;
import com.study.course_registration.entity.LessonSchedule;
@Component
public class ScheduleConflictChecker {
public boolean overlaps(LessonSchedule left, LessonSchedule right) {
return left.getDayOfWeek() == right.getDayOfWeek()
&& left.getStartTime().isBefore(right.getEndTime())
&& right.getStartTime().isBefore(left.getEndTime());
public final class ScheduleConflictChecker {
public boolean overlaps(ScheduleSlot left, ScheduleSlot right) {
return left.dayOfWeek() == right.dayOfWeek()
&& left.startTime().isBefore(right.endTime())
&& right.startTime().isBefore(left.endTime());
}
}
@@ -0,0 +1,11 @@
package com.study.course_registration.domain.schedule;
import java.time.DayOfWeek;
import java.time.LocalTime;
public record ScheduleSlot(
String lessonId,
DayOfWeek dayOfWeek,
LocalTime startTime,
LocalTime endTime) {
}
@@ -2,20 +2,8 @@ package com.study.course_registration.failure;
import com.study.course_registration.enums.RegistrationErrorCode;
public abstract class ApplicationFailure extends RuntimeException {
private final RegistrationErrorCode errorCode;
public abstract class ApplicationFailure extends KnownFailure {
protected ApplicationFailure(RegistrationErrorCode errorCode, String message) {
super(message);
this.errorCode = errorCode;
}
protected ApplicationFailure(RegistrationErrorCode errorCode, String message, Throwable cause) {
super(message, cause);
this.errorCode = errorCode;
}
public RegistrationErrorCode getErrorCode() {
return errorCode;
super(errorCode, message);
}
}
@@ -0,0 +1,21 @@
package com.study.course_registration.failure;
import com.study.course_registration.enums.RegistrationErrorCode;
public abstract class KnownFailure extends RuntimeException {
private final RegistrationErrorCode errorCode;
protected KnownFailure(RegistrationErrorCode errorCode, String message) {
super(message);
this.errorCode = errorCode;
}
protected KnownFailure(RegistrationErrorCode errorCode, String message, Throwable cause) {
super(message, cause);
this.errorCode = errorCode;
}
public RegistrationErrorCode getErrorCode() {
return errorCode;
}
}
@@ -2,7 +2,7 @@ package com.study.course_registration.failure;
import com.study.course_registration.enums.RegistrationErrorCode;
public final class RetryableInfrastructureFailure extends ApplicationFailure {
public final class RetryableInfrastructureFailure extends KnownFailure {
private RetryableInfrastructureFailure(String message, Throwable cause) {
super(RegistrationErrorCode.LOCK_TIMEOUT, message, cause);
}
@@ -0,0 +1,56 @@
package com.study.course_registration.infrastructure.persistence;
import org.springframework.dao.PessimisticLockingFailureException;
import org.springframework.stereotype.Component;
import com.study.course_registration.application.registration.port.CancellationContextLoader;
import com.study.course_registration.domain.registration.CancellationContext;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.failure.ResourceNotFound;
import com.study.course_registration.failure.RetryableInfrastructureFailure;
import com.study.course_registration.infrastructure.persistence.repository.LessonRepository;
import com.study.course_registration.infrastructure.persistence.repository.UserLessonRepository;
import com.study.course_registration.infrastructure.persistence.repository.UserRepository;
import jakarta.persistence.LockTimeoutException;
import jakarta.persistence.PessimisticLockException;
@Component
public class JpaCancellationContextLoader implements CancellationContextLoader {
private final UserRepository users;
private final LessonRepository lessons;
private final UserLessonRepository registrations;
public JpaCancellationContextLoader(
UserRepository users,
LessonRepository lessons,
UserLessonRepository registrations) {
this.users = users;
this.lessons = lessons;
this.registrations = registrations;
}
@Override
public CancellationContext load(String registrationId) {
UserLessonRepository.RegistrationTarget target =
registrations.findTargetById(registrationId)
.orElseThrow(ResourceNotFound::registration);
try {
users.findByIdForUpdate(target.getUserId()).orElseThrow(ResourceNotFound::user);
Lesson lesson = lessons.findByIdForUpdate(target.getLessonId())
.orElseThrow(ResourceNotFound::lesson);
UserLesson registration = registrations.findById(registrationId)
.orElseThrow(ResourceNotFound::registration);
return new CancellationContext(
target.getUserId(),
registration.getId(),
JpaSnapshotMapper.lessonPolicy(lesson),
registration.isCanceled());
} catch (PessimisticLockingFailureException | LockTimeoutException | PessimisticLockException exception) {
throw RetryableInfrastructureFailure.lockTimeout(exception);
}
}
}
@@ -6,20 +6,46 @@ import java.util.Optional;
import org.springframework.stereotype.Component;
import com.study.course_registration.application.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.repository.LessonRepository;
import com.study.course_registration.infrastructure.persistence.repository.RegistrationIdempotencyRepository;
import com.study.course_registration.infrastructure.persistence.repository.UserLessonRepository;
import com.study.course_registration.infrastructure.persistence.repository.UserRepository;
@Component
public class JpaIdempotencyAdapter implements IdempotencyPort {
private final RegistrationIdempotencyRepository repository;
private final UserRepository users;
private final LessonRepository lessons;
private final UserLessonRepository registrations;
public JpaIdempotencyAdapter(RegistrationIdempotencyRepository repository) {
public JpaIdempotencyAdapter(
RegistrationIdempotencyRepository repository,
UserRepository users,
LessonRepository lessons,
UserLessonRepository registrations) {
this.repository = repository;
this.users = users;
this.lessons = lessons;
this.registrations = registrations;
}
@Override
public Optional<RegistrationIdempotency> findActive(String userId, String key, Instant now) {
return repository.findByUser_IdAndIdempotencyKeyAndExpiresAtAfter(userId, key, now);
public Optional<ReplayRecord> findActive(String userId, String key, Instant now) {
return repository.findByUser_IdAndIdempotencyKeyAndExpiresAtAfter(userId, key, now)
.map(stored -> new ReplayRecord(
stored.getRegistration().getId(),
stored.getUser().getId(),
stored.getLesson().getId(),
stored.getLesson().getName(),
stored.getLesson().getSubject().getCode(),
stored.getLesson().getSubject().getCredit(),
stored.getRegistration().getCreatedAt(),
stored.getTotalCredits()));
}
@Override
@@ -33,7 +59,18 @@ public class JpaIdempotencyAdapter implements IdempotencyPort {
}
@Override
public RegistrationIdempotency save(RegistrationIdempotency idempotency) {
return repository.saveAndFlush(idempotency);
public void save(SaveCommand 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(
user,
lesson,
registration,
command.key(),
command.totalCredits(),
command.expiresAt()));
}
}
@@ -1,6 +1,5 @@
package com.study.course_registration.infrastructure.persistence;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@@ -14,8 +13,8 @@ import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Component;
import com.study.course_registration.application.lesson.port.LessonQueryPort;
import com.study.course_registration.domain.schedule.ScheduleSlot;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.infrastructure.persistence.repository.LessonRepository;
import com.study.course_registration.infrastructure.persistence.repository.LessonScheduleRepository;
import com.study.course_registration.infrastructure.persistence.repository.UserLessonRepository;
@@ -46,21 +45,71 @@ public class JpaLessonQueryAdapter implements LessonQueryPort {
? lessons.findBySemester_Id(semesterId, pageable)
: lessons.findBySemester_IdAndSubject_Id(semesterId, subjectId, pageable);
return new LessonPage(result.getContent(), result.getTotalElements());
List<String> lessonIds = result.getContent().stream()
.map(Lesson::getId)
.toList();
Map<String, List<ScheduleSlot>> scheduleMap = schedules(lessonIds);
Map<String, Long> counts = enrollmentCounts(lessonIds);
List<LessonListView> views = result.getContent().stream()
.map(lesson -> new LessonListView(
lesson.getId(),
lesson.getName(),
lesson.getSubject().getCode(),
lesson.getSubject().getName(),
lesson.getSubject().getCredit(),
lesson.getProfessor().getName(),
lesson.getCapacity(),
counts.getOrDefault(lesson.getId(), 0L),
lesson.getMinGrade(),
lesson.getAllowedRole(),
scheduleMap.getOrDefault(lesson.getId(), List.of())))
.toList();
return new LessonPage(views, result.getTotalElements());
}
@Override
public Optional<Lesson> findDetailed(String lessonId) {
return lessons.findDetailedById(lessonId);
public Optional<LessonDetailView> findDetailed(String lessonId) {
return lessons.findDetailedById(lessonId)
.map(lesson -> {
Map<String, List<ScheduleSlot>> scheduleMap = schedules(List.of(lessonId));
Map<String, Long> counts = enrollmentCounts(List.of(lessonId));
return new LessonDetailView(
lesson.getId(),
lesson.getName(),
lesson.getSubject().getCode(),
lesson.getSubject().getName(),
lesson.getSubject().getDescription(),
lesson.getSubject().getCredit(),
lesson.getProfessor().getName(),
lesson.getSemester().getName(),
lesson.getCapacity(),
counts.getOrDefault(lessonId, 0L),
lesson.getMinGrade(),
lesson.getAllowedRole(),
lesson.getSemester().getRegistrationStartAt(),
lesson.getSemester().getRegistrationEndAt(),
scheduleMap.getOrDefault(lessonId, List.of()));
});
}
@Override
public List<LessonSchedule> findSchedules(Collection<String> lessonIds) {
return schedules.findByLesson_IdInOrderByDayOfWeekAscStartTimeAsc(lessonIds);
private Map<String, List<ScheduleSlot>> schedules(List<String> lessonIds) {
if (lessonIds.isEmpty()) {
return Map.of();
}
return schedules.findByLesson_IdInOrderByDayOfWeekAscStartTimeAsc(lessonIds).stream()
.map(JpaSnapshotMapper::schedule)
.collect(Collectors.groupingBy(
ScheduleSlot::lessonId,
LinkedHashMap::new,
Collectors.toList()));
}
@Override
public Map<String, Long> countActiveEnrollments(Collection<String> lessonIds) {
private Map<String, Long> enrollmentCounts(List<String> lessonIds) {
if (lessonIds.isEmpty()) {
return Map.of();
}
return registrations.countActiveByLessonIds(lessonIds).stream()
.collect(Collectors.toMap(
UserLessonRepository.LessonEnrollmentCount::getLessonId,
@@ -8,33 +8,32 @@ import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.springframework.dao.PessimisticLockingFailureException;
import org.springframework.stereotype.Component;
import com.study.course_registration.application.registration.port.RegistrationContextLoader;
import com.study.course_registration.application.registration.port.RegistrationDecisionContextLoader;
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.RegistrationExecutionScope;
import com.study.course_registration.domain.registration.UserProfile;
import com.study.course_registration.domain.schedule.ScheduleSlot;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
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.failure.RetryableInfrastructureFailure;
import com.study.course_registration.infrastructure.persistence.repository.LessonRepository;
import com.study.course_registration.infrastructure.persistence.repository.LessonScheduleRepository;
import com.study.course_registration.infrastructure.persistence.repository.UserLessonRepository;
import com.study.course_registration.infrastructure.persistence.repository.UserRepository;
import jakarta.persistence.LockTimeoutException;
import jakarta.persistence.PessimisticLockException;
@Component
public class JpaRegistrationContextLoader implements RegistrationContextLoader {
public class JpaRegistrationDecisionContextLoader implements RegistrationDecisionContextLoader {
private final UserRepository users;
private final LessonRepository lessons;
private final UserLessonRepository registrations;
private final LessonScheduleRepository schedules;
public JpaRegistrationContextLoader(
public JpaRegistrationDecisionContextLoader(
UserRepository users,
LessonRepository lessons,
UserLessonRepository registrations,
@@ -46,44 +45,40 @@ public class JpaRegistrationContextLoader implements RegistrationContextLoader {
}
@Override
public RegistrationContext loadForRegistration(String userId, String lessonId, Instant now) {
LockedRegistration locked = lockForUpdate(userId, lessonId);
List<UserLesson> active = registrations.findActiveByUserIdAndSemesterId(
locked.user().getId(),
locked.lesson().getSemester().getId());
public RegistrationContext load(RegistrationExecutionScope scope, Instant now) {
User userEntity = users.findById(scope.userId()).orElseThrow(ResourceNotFound::user);
Lesson lessonEntity = lessons.findDetailedById(scope.lessonId()).orElseThrow(ResourceNotFound::lesson);
UserProfile user = JpaSnapshotMapper.user(userEntity);
LessonPolicySnapshot lesson = JpaSnapshotMapper.lessonPolicy(lessonEntity);
List<UserLesson> activeEntities =
registrations.findActiveByUserIdAndSemesterId(user.id(), lesson.semesterId());
List<ActiveRegistrationSnapshot> active = activeEntities.stream()
.map(JpaSnapshotMapper::activeRegistration)
.toList();
Set<String> lessonIds = active.stream()
.map(UserLesson::getLesson)
.map(Lesson::getId)
.map(ActiveRegistrationSnapshot::lessonId)
.collect(Collectors.toCollection(LinkedHashSet::new));
lessonIds.add(locked.lesson().getId());
lessonIds.add(lesson.id());
Map<String, List<LessonSchedule>> schedulesByLessonId =
Map<String, List<ScheduleSlot>> schedulesByLessonId =
schedules.findByLesson_IdInOrderByDayOfWeekAscStartTimeAsc(lessonIds).stream()
.map(JpaSnapshotMapper::schedule)
.collect(Collectors.groupingBy(
schedule -> schedule.getLesson().getId(),
ScheduleSlot::lessonId,
LinkedHashMap::new,
Collectors.toList()));
long enrolled = registrations.countByLesson_IdAndCanceledAtIsNull(locked.lesson().getId());
long enrolled = registrations.countByLesson_IdAndCanceledAtIsNull(lesson.id());
return new RegistrationContext(
locked.user(),
locked.lesson(),
user,
lesson,
active,
schedulesByLessonId,
enrolled,
now);
}
@Override
public LockedRegistration lockForUpdate(String userId, String lessonId) {
try {
User user = users.findByIdForUpdate(userId).orElseThrow(ResourceNotFound::user);
Lesson lesson = lessons.findByIdForUpdate(lessonId).orElseThrow(ResourceNotFound::lesson);
return new LockedRegistration(user, lesson);
} catch (PessimisticLockingFailureException | LockTimeoutException | PessimisticLockException exception) {
throw RetryableInfrastructureFailure.lockTimeout(exception);
}
}
}
@@ -0,0 +1,38 @@
package com.study.course_registration.infrastructure.persistence;
import org.springframework.dao.PessimisticLockingFailureException;
import org.springframework.stereotype.Component;
import com.study.course_registration.application.registration.port.RegistrationExecutionScopeLoader;
import com.study.course_registration.domain.registration.RegistrationExecutionScope;
import com.study.course_registration.failure.ResourceNotFound;
import com.study.course_registration.failure.RetryableInfrastructureFailure;
import com.study.course_registration.infrastructure.persistence.repository.LessonRepository;
import com.study.course_registration.infrastructure.persistence.repository.UserRepository;
import jakarta.persistence.LockTimeoutException;
import jakarta.persistence.PessimisticLockException;
@Component
public class JpaRegistrationExecutionScopeLoader implements RegistrationExecutionScopeLoader {
private final UserRepository users;
private final LessonRepository lessons;
public JpaRegistrationExecutionScopeLoader(
UserRepository users,
LessonRepository lessons) {
this.users = users;
this.lessons = lessons;
}
@Override
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);
}
}
}
@@ -1,15 +1,22 @@
package com.study.course_registration.infrastructure.persistence;
import java.util.Collection;
import java.time.Instant;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Optional;
import java.util.Map;
import java.util.stream.Collectors;
import org.springframework.stereotype.Component;
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;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
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.repository.LessonRepository;
import com.study.course_registration.infrastructure.persistence.repository.LessonScheduleRepository;
import com.study.course_registration.infrastructure.persistence.repository.UserLessonRepository;
import com.study.course_registration.infrastructure.persistence.repository.UserRepository;
@@ -17,14 +24,17 @@ import com.study.course_registration.infrastructure.persistence.repository.UserR
@Component
public class JpaRegistrationPersistenceAdapter implements RegistrationReader, RegistrationWriter {
private final UserRepository users;
private final LessonRepository lessons;
private final UserLessonRepository registrations;
private final LessonScheduleRepository schedules;
public JpaRegistrationPersistenceAdapter(
UserRepository users,
LessonRepository lessons,
UserLessonRepository registrations,
LessonScheduleRepository schedules) {
this.users = users;
this.lessons = lessons;
this.registrations = registrations;
this.schedules = schedules;
}
@@ -35,28 +45,55 @@ public class JpaRegistrationPersistenceAdapter implements RegistrationReader, Re
}
@Override
public Optional<RegistrationTarget> findTarget(String registrationId) {
return registrations.findTargetById(registrationId)
.map(target -> new RegistrationTarget(target.getUserId(), target.getLessonId()));
public List<ActiveRegistrationView> findActive(String userId, String semesterId) {
List<UserLesson> active =
registrations.findActiveByUserIdAndSemesterId(userId, semesterId);
List<String> lessonIds = active.stream()
.map(UserLesson::getLesson)
.map(Lesson::getId)
.toList();
Map<String, List<ScheduleSlot>> schedulesByLessonId = lessonIds.isEmpty()
? Map.of()
: schedules.findByLesson_IdInOrderByDayOfWeekAscStartTimeAsc(lessonIds).stream()
.map(JpaSnapshotMapper::schedule)
.collect(Collectors.groupingBy(
ScheduleSlot::lessonId,
LinkedHashMap::new,
Collectors.toList()));
return active.stream()
.map(registration -> {
Lesson lesson = registration.getLesson();
return new ActiveRegistrationView(
registration.getId(),
lesson.getId(),
lesson.getName(),
lesson.getSubject().getCode(),
lesson.getSubject().getName(),
lesson.getSubject().getCredit(),
lesson.getProfessor().getName(),
schedulesByLessonId.getOrDefault(lesson.getId(), List.of()),
registration.getCreatedAt());
})
.toList();
}
@Override
public Optional<UserLesson> findRegistration(String registrationId) {
return registrations.findById(registrationId);
public RegistrationRecord create(String userId, String lessonId) {
User user = users.findById(userId).orElseThrow(ResourceNotFound::user);
Lesson lesson = lessons.findById(lessonId).orElseThrow(ResourceNotFound::lesson);
UserLesson saved = registrations.saveAndFlush(new UserLesson(user, lesson));
return new RegistrationRecord(saved.getId(), saved.getCreatedAt());
}
@Override
public List<UserLesson> findActive(String userId, String semesterId) {
return registrations.findActiveByUserIdAndSemesterId(userId, semesterId);
}
@Override
public List<LessonSchedule> findSchedules(Collection<String> lessonIds) {
return schedules.findByLesson_IdInOrderByDayOfWeekAscStartTimeAsc(lessonIds);
}
@Override
public UserLesson save(UserLesson registration) {
return registrations.saveAndFlush(registration);
public void cancel(String registrationId, Instant canceledAt) {
UserLesson registration = registrations.findById(registrationId)
.orElseThrow(ResourceNotFound::registration);
if (!registration.isCanceled()) {
registration.cancel(canceledAt);
registrations.saveAndFlush(registration);
}
}
}
@@ -7,8 +7,8 @@ import java.util.Optional;
import org.springframework.stereotype.Component;
import com.study.course_registration.application.semester.SemesterSnapshot;
import com.study.course_registration.application.semester.port.SemesterQueryPort;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.infrastructure.persistence.repository.SemesterRepository;
@Component
@@ -20,17 +20,23 @@ public class JpaSemesterQueryAdapter implements SemesterQueryPort {
}
@Override
public Optional<Semester> findById(String semesterId) {
return repository.findById(semesterId);
public Optional<SemesterSnapshot> findById(String semesterId) {
return repository.findById(semesterId).map(JpaSnapshotMapper::semester);
}
@Override
public List<Semester> findRegistrationSemesters(Instant now) {
return repository.findByRegistrationStartAtLessThanEqualAndRegistrationEndAtGreaterThanEqual(now, now);
public List<SemesterSnapshot> findRegistrationSemesters(Instant now) {
return repository.findByRegistrationStartAtLessThanEqualAndRegistrationEndAtGreaterThanEqual(now, now)
.stream()
.map(JpaSnapshotMapper::semester)
.toList();
}
@Override
public List<Semester> findAcademicSemesters(LocalDate today) {
return repository.findByStartDateLessThanEqualAndEndDateGreaterThanEqual(today, today);
public List<SemesterSnapshot> findAcademicSemesters(LocalDate today) {
return repository.findByStartDateLessThanEqualAndEndDateGreaterThanEqual(today, today)
.stream()
.map(JpaSnapshotMapper::semester)
.toList();
}
}
@@ -0,0 +1,67 @@
package com.study.course_registration.infrastructure.persistence;
import com.study.course_registration.application.semester.SemesterSnapshot;
import com.study.course_registration.domain.registration.ActiveRegistrationSnapshot;
import com.study.course_registration.domain.registration.LessonPolicySnapshot;
import com.study.course_registration.domain.registration.UserProfile;
import com.study.course_registration.domain.schedule.ScheduleSlot;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.entity.User;
import com.study.course_registration.entity.UserLesson;
final class JpaSnapshotMapper {
private JpaSnapshotMapper() {
}
static UserProfile user(User entity) {
return new UserProfile(
entity.getId(),
entity.getGrade(),
entity.getRole());
}
static LessonPolicySnapshot lessonPolicy(Lesson entity) {
return new LessonPolicySnapshot(
entity.getId(),
entity.getName(),
entity.getSubject().getId(),
entity.getSubject().getCode(),
entity.getSubject().getCredit(),
entity.getSemester().getId(),
entity.getSemester().getRegistrationStartAt(),
entity.getSemester().getRegistrationEndAt(),
entity.getSemester().getMaxCredits(),
entity.getCapacity(),
entity.getMinGrade(),
entity.getAllowedRole());
}
static ActiveRegistrationSnapshot activeRegistration(UserLesson entity) {
return new ActiveRegistrationSnapshot(
entity.getId(),
entity.getLesson().getId(),
entity.getLesson().getSubject().getId(),
entity.getLesson().getSubject().getCredit());
}
static ScheduleSlot schedule(LessonSchedule entity) {
return new ScheduleSlot(
entity.getLesson().getId(),
entity.getDayOfWeek(),
entity.getStartTime(),
entity.getEndTime());
}
static SemesterSnapshot semester(Semester entity) {
return new SemesterSnapshot(
entity.getId(),
entity.getName(),
entity.getStartDate(),
entity.getEndDate(),
entity.getRegistrationStartAt(),
entity.getRegistrationEndAt(),
entity.getMaxCredits());
}
}
@@ -24,6 +24,7 @@ import com.study.course_registration.entity.Subject;
import com.study.course_registration.entity.User;
import com.study.course_registration.enums.UserRole;
import com.study.course_registration.domain.schedule.LessonSchedulePolicy;
import com.study.course_registration.domain.schedule.ScheduleSlot;
import jakarta.persistence.EntityManager;
@@ -112,7 +113,13 @@ public class DataSeeder implements CommandLineRunner {
DayOfWeek.valueOf(row.text("dayOfWeek")), LocalTime.parse(row.text("startTime")),
LocalTime.parse(row.text("endTime"))));
}
schedulePolicy.validate(schedules);
schedulePolicy.validate(schedules.stream()
.map(schedule -> new ScheduleSlot(
schedule.getLesson().getId(),
schedule.getDayOfWeek(),
schedule.getStartTime(),
schedule.getEndTime()))
.toList());
schedules.forEach(entityManager::persist);
}
@@ -3,7 +3,7 @@ package com.study.course_registration.web.dto;
import java.time.DayOfWeek;
import java.time.LocalTime;
import com.study.course_registration.application.common.ScheduleSlot;
import com.study.course_registration.domain.schedule.ScheduleSlot;
public record ScheduleResponse(
DayOfWeek dayOfWeek,
@@ -4,6 +4,7 @@ import org.springframework.stereotype.Component;
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;
@@ -17,12 +18,14 @@ public class FailureMetrics {
this.registry = registry;
}
public void record(ApplicationFailure failure) {
public void record(KnownFailure failure) {
String category = failure instanceof BusinessRejection
? "business_rejection"
: failure instanceof RetryableInfrastructureFailure
? "retryable_infrastructure"
: "application_failure";
: failure instanceof ApplicationFailure
? "application_failure"
: "known_failure";
registry.counter(
"application_failure_total",
"category", category,
@@ -1,4 +1,4 @@
package com.study.course_registration.service;
package com.study.course_registration.application.lesson;
import static org.assertj.core.api.Assertions.assertThat;
@@ -31,7 +31,7 @@ import com.study.course_registration.support.fixture.DomainFixtures;
import jakarta.persistence.EntityManagerFactory;
class LessonQueryServiceIntegrationTest extends PostgresIntegrationTest {
class LessonQueryIntegrationTest extends PostgresIntegrationTest {
private static final Rejections<ApplicationFailure, RegistrationErrorCode> REJECTIONS =
Rejections.of(ApplicationFailure.class, ApplicationFailure::getErrorCode);
@@ -1,4 +1,4 @@
package com.study.course_registration.service;
package com.study.course_registration.application.registration;
import static org.assertj.core.api.Assertions.assertThat;
@@ -0,0 +1,75 @@
package com.study.course_registration.application.registration;
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.time.Clock;
import java.time.ZoneOffset;
import java.util.Optional;
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.port.RegistrationExecutionScopeLoader;
import com.study.course_registration.application.registration.port.RegistrationWriter;
import com.study.course_registration.domain.registration.RegistrationExecutionScope;
import com.study.course_registration.domain.registration.RegistrationPolicy;
import com.study.course_registration.domain.registration.RegistrationWindowGuard;
import com.study.course_registration.support.fixture.TestData;
class RegisterCourseUseCaseTest {
@Test
@DisplayName("idempotency replay → decision context 조회와 write 없이 즉시 반환")
void replaySkipsDecisionContextLoading() {
RegistrationExecutionScopeLoader scopes = mock(RegistrationExecutionScopeLoader.class);
RegistrationDecisionContextLoader contexts = mock(RegistrationDecisionContextLoader.class);
RegistrationWriter registrations = mock(RegistrationWriter.class);
RegistrationPolicy policy = mock(RegistrationPolicy.class);
RegistrationWindowGuard windowGuard = mock(RegistrationWindowGuard.class);
IdempotencyCoordinator idempotency = mock(IdempotencyCoordinator.class);
RegistrationExecutionScope scope =
new RegistrationExecutionScope("user", "lesson");
ReplayRecord replay = new ReplayRecord(
"registration",
"user",
"lesson",
"자료구조",
"CS101",
3,
TestData.NOW,
3);
when(scopes.open("user", "lesson")).thenReturn(scope);
when(idempotency.evaluate("user", "lesson", "retry", TestData.NOW))
.thenReturn(new Decision("retry", Optional.of(replay)));
RegisterCourseUseCase useCase = new RegisterCourseUseCase(
Clock.fixed(TestData.NOW, ZoneOffset.UTC),
scopes,
contexts,
registrations,
policy,
windowGuard,
idempotency);
RegistrationResult result = useCase.execute(
new RegisterCourseCommand("user", "lesson", "retry"));
InOrder order = inOrder(scopes, idempotency);
order.verify(scopes).open("user", "lesson");
order.verify(idempotency).evaluate("user", "lesson", "retry", TestData.NOW);
verifyNoInteractions(contexts, registrations, policy, windowGuard);
assertThat(result.registrationId()).isEqualTo("registration");
assertThat(result.registeredAt()).isEqualTo(TestData.NOW);
}
}
@@ -1,4 +1,4 @@
package com.study.course_registration.service;
package com.study.course_registration.application.registration;
import static org.assertj.core.api.Assertions.assertThat;
@@ -31,7 +31,7 @@ import com.study.course_registration.support.fixture.DatabaseFixture.Registratio
import com.study.course_registration.support.fixture.DomainFixtures;
import com.study.course_registration.support.fixture.TestData;
class CourseRegistrationServiceIntegrationTest extends PostgresIntegrationTest {
class RegistrationUseCaseIntegrationTest extends PostgresIntegrationTest {
private static final Rejections<ApplicationFailure, RegistrationErrorCode> REJECTIONS =
Rejections.of(ApplicationFailure.class, ApplicationFailure::getErrorCode);
@@ -1,4 +1,4 @@
package com.study.course_registration.service;
package com.study.course_registration.application.semester;
import static org.assertj.core.api.Assertions.assertThat;
@@ -19,7 +19,7 @@ import com.study.course_registration.support.Scenario;
import com.study.course_registration.support.fixture.DatabaseFixture;
import com.study.course_registration.support.fixture.DomainFixtures;
class SemesterResolverIntegrationTest extends PostgresIntegrationTest {
class SemesterSelectionPolicyIntegrationTest extends PostgresIntegrationTest {
private static final Rejections<ApplicationFailure, RegistrationErrorCode> REJECTIONS =
Rejections.of(ApplicationFailure.class, ApplicationFailure::getErrorCode);
private static final Rejections<SystemInvariantViolation, InvariantCode> INVARIANTS =
@@ -40,7 +40,7 @@ class SemesterResolverIntegrationTest extends PostgresIntegrationTest {
Scenario.given(semester.getId())
.when(policy::resolve)
.then(result -> assertThat(result.getId()).isEqualTo(semester.getId()));
.then(result -> assertThat(result.id()).isEqualTo(semester.getId()));
}
@Test
@@ -51,7 +51,7 @@ class SemesterResolverIntegrationTest extends PostgresIntegrationTest {
Scenario.given((String) null)
.when(policy::resolve)
.then(result -> assertThat(result.getId()).isEqualTo(semester.getId()));
.then(result -> assertThat(result.id()).isEqualTo(semester.getId()));
}
@Test
@@ -21,65 +21,69 @@ class ArchitectureTest {
new ClassFileImporter().importPath(Path.of("build/classes/java/main"));
@Test
@DisplayName("수강신청 UseCase → RegistrationContextLoader port 의존")
void registrationMutationUsesContextPort() {
@DisplayName("등록 UseCase → execution scope와 decision context port로 흐름 분리")
void registrationMutationUsesBusinessNamedPorts() {
classes()
.that().haveSimpleName("RegisterCourseUseCase")
.should().dependOnClassesThat().haveSimpleName("RegistrationContextLoader")
.should().dependOnClassesThat().haveSimpleName("RegistrationExecutionScopeLoader")
.andShould().dependOnClassesThat().haveSimpleName("RegistrationDecisionContextLoader")
.check(classes);
classes()
.that().haveSimpleName("CancelRegistrationUseCase")
.should().dependOnClassesThat().haveSimpleName("RegistrationContextLoader")
.should().dependOnClassesThat().haveSimpleName("CancellationContextLoader")
.check(classes);
}
@Test
@DisplayName("application → Spring Data JPA·repository·web 표현 의존 금지")
void applicationDoesNotKnowPersistenceMechanismOrWebRepresentation() {
@DisplayName("application → JPA entity·Spring Data·infrastructure·web 의존 금지")
void applicationDoesNotKnowPersistenceModelOrMechanism() {
noClasses()
.that().resideInAPackage("..application..")
.should().dependOnClassesThat().resideInAnyPackage(
"..repository..",
"org.springframework.data..",
"jakarta.persistence..",
"..web..",
"..dto..")
.check(classes);
}
@Test
@DisplayName("domain → application·infrastructure·web·repository 의존 금지")
void domainStaysInsideDomainBoundary() {
noClasses()
.that().resideInAPackage("..domain..")
.should().dependOnClassesThat().resideInAnyPackage(
"..application..",
"..entity..",
"..infrastructure..",
"..web..",
"..repository..",
"org.springframework.data..",
"jakarta.persistence..")
.check(classes);
}
@Test
@DisplayName("web → repository·infrastructure 직접 접근 금지")
void webDependsOnApplicationBoundary() {
@DisplayName("domain → Spring·JPA entity·상위 계층 의존 금지")
void domainIsFrameworkIndependent() {
noClasses()
.that().resideInAPackage("..web..")
.that().resideInAPackage("..domain..")
.should().dependOnClassesThat().resideInAnyPackage(
"..repository..",
"..infrastructure..")
"..application..",
"..entity..",
"..infrastructure..",
"..web..",
"org.springframework..",
"jakarta.persistence..")
.check(classes);
}
@Test
@DisplayName("JPA repository → infrastructure 밖 application에서 직접 참조 금지")
void rawRepositoriesStayBehindInfrastructureAdapters() {
@DisplayName("web → infrastructure·JPA entity 직접 접근 금지")
void webDependsOnApplicationBoundary() {
noClasses()
.that().resideInAPackage("..application..")
.should().dependOnClassesThat().resideInAPackage("..repository..")
.that().resideInAPackage("..web..")
.should().dependOnClassesThat().resideInAnyPackage(
"..infrastructure..",
"..entity..")
.check(classes);
}
@Test
@DisplayName("application port → persistence model 노출 금지")
void applicationPortsExposeOnlyBoundaryModels() {
noClasses()
.that().resideInAPackage("..application..port..")
.should().dependOnClassesThat().resideInAnyPackage(
"..entity..",
"org.springframework.data..",
"jakarta.persistence..")
.check(classes);
}
@@ -1,14 +1,13 @@
package com.study.course_registration.service.policy;
package com.study.course_registration.domain.registration;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import com.study.course_registration.domain.registration.RegistrationContext;
import com.study.course_registration.domain.registration.RegistrationPolicy;
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;
@@ -19,13 +18,8 @@ import com.study.course_registration.domain.registration.rule.RoleEligibilityRul
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;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.entity.User;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.domain.schedule.ScheduleSlot;
import com.study.course_registration.enums.UserRole;
import com.study.course_registration.support.fixture.DomainFixtures;
import com.study.course_registration.support.fixture.TestData;
final class RegistrationFixture {
@@ -33,14 +27,20 @@ final class RegistrationFixture {
private static final String EXISTING_LESSON_ID = "lesson-a";
private final RegistrationPolicy policy = policy();
private Semester semester = DomainFixtures.openSemester("semester-1", "2026-1", 18);
private final long grade;
private String semesterId = "semester-1";
private Instant registrationStartAt = TestData.NOW.minusSeconds(3600);
private Instant registrationEndAt = TestData.NOW.plusSeconds(3600);
private int maxCredits = 18;
private String candidateSubjectId = "subject-b";
private int candidateCredit = 3;
private int capacity = 30;
private Long minGrade;
private UserRole allowedRole;
private Slot candidateSlot = new Slot(DayOfWeek.MONDAY, 15, 16);
private boolean existingIsSameLesson;
private String existingSubjectId;
private int existingCredit = 3;
@@ -55,13 +55,15 @@ final class RegistrationFixture {
return new RegistrationFixture(grade);
}
RegistrationFixture semesterWithMaxCredits(int maxCredits) {
semester = DomainFixtures.openSemester("semester-1", "2026-1", maxCredits);
RegistrationFixture semesterWithMaxCredits(int value) {
maxCredits = value;
return this;
}
RegistrationFixture inClosedSemester() {
semester = DomainFixtures.closedSemester("semester-closed", "closed");
semesterId = "semester-closed";
registrationStartAt = TestData.NOW.minusSeconds(7200);
registrationEndAt = TestData.NOW.minusSeconds(3600);
return this;
}
@@ -137,65 +139,66 @@ final class RegistrationFixture {
}
Instant registrationStartAt() {
return semester.getRegistrationStartAt();
return registrationStartAt;
}
Instant registrationEndAt() {
return semester.getRegistrationEndAt();
return registrationEndAt;
}
private RegistrationContext context(Instant now) {
Fixture fixture = assemble();
UserProfile user = new UserProfile("user", grade, UserRole.STUDENT);
LessonPolicySnapshot candidate = candidate();
List<ActiveRegistrationSnapshot> active = new ArrayList<>();
Map<String, List<ScheduleSlot>> schedules = new LinkedHashMap<>();
if (candidateSlot != null) {
schedules.put(candidate.id(), List.of(candidateSlot.toSchedule(candidate.id())));
}
if (existingIsSameLesson) {
active.add(new ActiveRegistrationSnapshot(
"reg",
candidate.id(),
candidate.subjectId(),
candidate.subjectCredit()));
} else if (existingSubjectId != null) {
active.add(new ActiveRegistrationSnapshot(
"reg",
EXISTING_LESSON_ID,
existingSubjectId,
existingCredit));
if (existingSlot != null) {
schedules.put(
EXISTING_LESSON_ID,
List.of(existingSlot.toSchedule(EXISTING_LESSON_ID)));
}
}
return new RegistrationContext(
fixture.user(),
fixture.candidate(),
fixture.existingRegistrations(),
fixture.schedules(),
user,
candidate,
active,
schedules,
enrolledCount,
now);
}
private Fixture assemble() {
User user = DomainFixtures.student("user", grade);
Lesson candidate = DomainFixtures.lesson(
private LessonPolicySnapshot candidate() {
return new LessonPolicySnapshot(
CANDIDATE_LESSON_ID,
CANDIDATE_LESSON_ID,
DomainFixtures.subject(candidateSubjectId, candidateSubjectId, candidateCredit),
DomainFixtures.professor("prof-" + CANDIDATE_LESSON_ID),
semester,
candidateSubjectId,
candidateSubjectId,
candidateCredit,
semesterId,
registrationStartAt,
registrationEndAt,
maxCredits,
capacity,
minGrade,
allowedRole);
List<UserLesson> existing = new ArrayList<>();
Map<String, List<LessonSchedule>> schedules = new LinkedHashMap<>();
if (candidateSlot != null) {
schedules.put(
candidate.getId(),
List.of(candidateSlot.toSchedule("schedule-b", candidate)));
}
if (existingIsSameLesson) {
existing.add(DomainFixtures.registration("reg", user, candidate));
} else if (existingSubjectId != null) {
Lesson existingLesson = DomainFixtures.lesson(
EXISTING_LESSON_ID,
EXISTING_LESSON_ID,
DomainFixtures.subject(existingSubjectId, existingSubjectId, existingCredit),
DomainFixtures.professor("prof-" + EXISTING_LESSON_ID),
semester,
30,
null,
null);
existing.add(DomainFixtures.registration("reg", user, existingLesson));
if (existingSlot != null) {
schedules.put(
existingLesson.getId(),
List.of(existingSlot.toSchedule("schedule-a", existingLesson)));
}
}
return new Fixture(user, candidate, existing, schedules);
}
private static RegistrationPolicy policy() {
@@ -213,15 +216,12 @@ final class RegistrationFixture {
}
private record Slot(DayOfWeek day, int startHour, int endHour) {
LessonSchedule toSchedule(String id, Lesson lesson) {
return DomainFixtures.schedule(id, lesson, day, startHour, endHour);
ScheduleSlot toSchedule(String lessonId) {
return new ScheduleSlot(
lessonId,
day,
LocalTime.of(startHour, 0),
LocalTime.of(endHour, 0));
}
}
private record Fixture(
User user,
Lesson candidate,
List<UserLesson> existingRegistrations,
Map<String, List<LessonSchedule>> schedules) {
}
}
@@ -1,4 +1,4 @@
package com.study.course_registration.service.policy;
package com.study.course_registration.domain.registration;
import static org.assertj.core.api.Assertions.assertThat;
@@ -19,7 +19,7 @@ import com.study.course_registration.support.Rejections;
import com.study.course_registration.support.Scenario;
@DisplayName("수강신청 정책")
class RegistrationValidatorTest {
class RegistrationPolicyTest {
private static final Rejections<ApplicationFailure, RegistrationErrorCode> REJECTIONS =
Rejections.of(ApplicationFailure.class, ApplicationFailure::getErrorCode);
private static final Rejections<SystemInvariantViolation, InvariantCode> INVARIANTS =
@@ -0,0 +1,71 @@
package com.study.course_registration.domain.schedule;
import static org.assertj.core.api.Assertions.assertThatCode;
import java.time.DayOfWeek;
import java.time.LocalTime;
import java.util.List;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import com.study.course_registration.failure.InvariantCode;
import com.study.course_registration.failure.SystemInvariantViolation;
import com.study.course_registration.support.Rejections;
import com.study.course_registration.support.Scenario;
@DisplayName("강의 시간표 정책")
class LessonSchedulePolicyTest {
private static final Rejections<SystemInvariantViolation, InvariantCode> INVARIANTS =
Rejections.of(SystemInvariantViolation.class, SystemInvariantViolation::getInvariantCode);
private final LessonSchedulePolicy policy =
new LessonSchedulePolicy(new ScheduleConflictChecker());
@Test
@DisplayName("같은 강의 시간 겹침 → 거부")
void overlap() {
List<ScheduleSlot> schedules = List.of(
slot("lesson-a", DayOfWeek.MONDAY, 9, 11),
slot("lesson-a", DayOfWeek.MONDAY, 10, 12));
Scenario.given(schedules)
.whenRunning(policy::validate)
.thenRejectedWith(INVARIANTS, InvariantCode.OVERLAPPING_LESSON_SCHEDULE);
}
@Test
@DisplayName("같은 강의 경계 접촉 → 허용")
void boundary() {
List<ScheduleSlot> schedules = List.of(
slot("lesson-a", DayOfWeek.MONDAY, 9, 11),
slot("lesson-a", DayOfWeek.MONDAY, 11, 13));
assertThatCode(() -> policy.validate(schedules))
.doesNotThrowAnyException();
}
@Test
@DisplayName("서로 다른 강의 시간 겹침 → 허용")
void differentLessons() {
List<ScheduleSlot> schedules = List.of(
slot("lesson-a", DayOfWeek.MONDAY, 9, 11),
slot("lesson-b", DayOfWeek.MONDAY, 9, 11));
Scenario.given(schedules)
.whenRunning(policy::validate)
.thenAccepted();
}
private static ScheduleSlot slot(
String lessonId,
DayOfWeek day,
int start,
int end) {
return new ScheduleSlot(
lessonId,
day,
LocalTime.of(start, 0),
LocalTime.of(end, 0));
}
}
@@ -0,0 +1,50 @@
package com.study.course_registration.domain.schedule;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.DayOfWeek;
import java.time.LocalTime;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
@DisplayName("시간표 겹침")
class ScheduleConflictCheckerTest {
private final ScheduleConflictChecker checker = new ScheduleConflictChecker();
@ParameterizedTest(name = "{7}")
@CsvSource(textBlock = """
MONDAY, 9, 11, MONDAY, 10, 12, true, '같은 요일 겹침 → 충돌'
MONDAY, 9, 11, MONDAY, 11, 13, false, '경계 접촉 → 비충돌'
MONDAY, 9, 11, MONDAY, 13, 15, false, '같은 요일 비중첩 → 비충돌'
MONDAY, 9, 11, TUESDAY, 9, 11, false, '다른 요일 → 비충돌'
""")
void overlaps(
DayOfWeek dayA,
int startA,
int endA,
DayOfWeek dayB,
int startB,
int endB,
boolean expected,
String name) {
ScheduleSlot left = slot("left", dayA, startA, endA);
ScheduleSlot right = slot("right", dayB, startB, endB);
assertThat(checker.overlaps(left, right)).isEqualTo(expected);
assertThat(checker.overlaps(right, left)).isEqualTo(expected);
}
private static ScheduleSlot slot(
String lessonId,
DayOfWeek day,
int start,
int end) {
return new ScheduleSlot(
lessonId,
day,
LocalTime.of(start, 0),
LocalTime.of(end, 0));
}
}
@@ -1,4 +1,4 @@
package com.study.course_registration.service.lock;
package com.study.course_registration.infrastructure.persistence;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.inOrder;
@@ -11,41 +11,37 @@ import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.InOrder;
import com.study.course_registration.application.registration.port.RegistrationContextLoader.LockedRegistration;
import com.study.course_registration.domain.registration.RegistrationExecutionScope;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.User;
import com.study.course_registration.infrastructure.persistence.JpaRegistrationContextLoader;
import com.study.course_registration.infrastructure.persistence.repository.LessonRepository;
import com.study.course_registration.infrastructure.persistence.repository.LessonScheduleRepository;
import com.study.course_registration.infrastructure.persistence.repository.UserLessonRepository;
import com.study.course_registration.infrastructure.persistence.repository.UserRepository;
import com.study.course_registration.support.fixture.DomainFixtures;
class RegistrationLockManagerTest {
class JpaRegistrationExecutionScopeLoaderTest {
@Test
@DisplayName("락 획득 순서 → User 다음 Lesson")
@DisplayName("execution scope 확보 → User 다음 Lesson 순서로 직렬화")
void userThenLesson() {
UserRepository users = mock(UserRepository.class);
LessonRepository lessons = mock(LessonRepository.class);
UserLessonRepository registrations = mock(UserLessonRepository.class);
LessonScheduleRepository schedules = mock(LessonScheduleRepository.class);
User user = DomainFixtures.student(2);
Lesson lesson = DomainFixtures.lesson(
DomainFixtures.subject("LOCK"),
DomainFixtures.professor(),
DomainFixtures.openSemester());
when(users.findByIdForUpdate("user")).thenReturn(Optional.of(user));
when(lessons.findByIdForUpdate("lesson")).thenReturn(Optional.of(lesson));
JpaRegistrationContextLoader loader =
new JpaRegistrationContextLoader(users, lessons, registrations, schedules);
JpaRegistrationExecutionScopeLoader loader =
new JpaRegistrationExecutionScopeLoader(users, lessons);
LockedRegistration result = loader.lockForUpdate("user", "lesson");
RegistrationExecutionScope scope = loader.open("user", "lesson");
InOrder order = inOrder(users, lessons);
order.verify(users).findByIdForUpdate("user");
order.verify(lessons).findByIdForUpdate("lesson");
assertThat(result.user()).isSameAs(user);
assertThat(result.lesson()).isSameAs(lesson);
assertThat(scope.userId()).isEqualTo("user");
assertThat(scope.lessonId()).isEqualTo("lesson");
}
}
@@ -1,4 +1,4 @@
package com.study.course_registration.service;
package com.study.course_registration.infrastructure.scheduling;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -1,76 +0,0 @@
package com.study.course_registration.service.policy;
import static org.assertj.core.api.Assertions.assertThatCode;
import java.time.DayOfWeek;
import java.util.List;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import com.study.course_registration.domain.schedule.LessonSchedulePolicy;
import com.study.course_registration.domain.schedule.ScheduleConflictChecker;
import com.study.course_registration.failure.InvariantCode;
import com.study.course_registration.failure.SystemInvariantViolation;
import com.study.course_registration.support.Rejections;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.entity.Professor;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.entity.Subject;
import com.study.course_registration.support.Scenario;
import com.study.course_registration.support.fixture.DomainFixtures;
@DisplayName("강의 시간표 정책")
class LessonSchedulePolicyTest {
private static final Rejections<SystemInvariantViolation, InvariantCode> INVARIANTS =
Rejections.of(SystemInvariantViolation.class, SystemInvariantViolation::getInvariantCode);
private final LessonSchedulePolicy policy = new LessonSchedulePolicy(new ScheduleConflictChecker());
@Test
@DisplayName("같은 강의 시간 겹침 → 거부")
void overlap() {
Semester semester = DomainFixtures.openSemester();
Subject subject = DomainFixtures.subject("CS101");
Lesson lesson = DomainFixtures.lesson(subject, DomainFixtures.professor(), semester);
List<LessonSchedule> schedules = List.of(
DomainFixtures.schedule(lesson, DayOfWeek.MONDAY, 9, 11),
DomainFixtures.schedule(lesson, DayOfWeek.MONDAY, 10, 12));
Scenario.given(schedules)
.whenRunning(policy::validate)
.thenRejectedWith(INVARIANTS, InvariantCode.OVERLAPPING_LESSON_SCHEDULE);
}
@Test
@DisplayName("같은 강의 경계 접촉 → 허용")
void boundary() {
Semester semester = DomainFixtures.openSemester();
Subject subject = DomainFixtures.subject("CS101");
Lesson lesson = DomainFixtures.lesson(subject, DomainFixtures.professor(), semester);
List<LessonSchedule> schedules = List.of(
DomainFixtures.schedule(lesson, DayOfWeek.MONDAY, 9, 11),
DomainFixtures.schedule(lesson, DayOfWeek.MONDAY, 11, 13));
assertThatCode(() -> policy.validate(schedules)).doesNotThrowAnyException();
}
@Test
@DisplayName("서로 다른 강의 시간 겹침 → 허용")
void differentLessons() {
Semester semester = DomainFixtures.openSemester();
Professor professor = DomainFixtures.professor();
Lesson left = DomainFixtures.lesson(DomainFixtures.subject("CS101"), professor, semester);
Lesson right = DomainFixtures.lesson(DomainFixtures.subject("CS102"), professor, semester);
List<LessonSchedule> schedules = List.of(
DomainFixtures.schedule(left, DayOfWeek.MONDAY, 9, 11),
DomainFixtures.schedule(right, DayOfWeek.MONDAY, 9, 11));
Scenario.given(schedules)
.whenRunning(policy::validate)
.thenAccepted();
}
}
@@ -1,34 +0,0 @@
package com.study.course_registration.service.policy;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.DayOfWeek;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import com.study.course_registration.domain.schedule.ScheduleConflictChecker;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.support.fixture.DomainFixtures;
@DisplayName("시간표 겹침")
class ScheduleConflictCheckerTest {
private final ScheduleConflictChecker checker = new ScheduleConflictChecker();
@ParameterizedTest(name = "{7}")
@CsvSource(textBlock = """
MONDAY, 9, 11, MONDAY, 10, 12, true, '같은 요일 겹침 → 충돌'
MONDAY, 9, 11, MONDAY, 11, 13, false, '경계 접촉 → 비충돌'
MONDAY, 9, 11, MONDAY, 13, 15, false, '같은 요일 비중첩 → 비충돌'
MONDAY, 9, 11, TUESDAY, 9, 11, false, '다른 요일 → 비충돌'
""")
void overlaps(DayOfWeek dayA, int startA, int endA, DayOfWeek dayB, int startB, int endB,
boolean expected, String name) {
LessonSchedule a = DomainFixtures.schedule(dayA, startA, endA);
LessonSchedule b = DomainFixtures.schedule(dayB, startB, endB);
assertThat(checker.overlaps(a, b)).isEqualTo(expected);
assertThat(checker.overlaps(b, a)).isEqualTo(expected);
}
}
@@ -1,4 +1,4 @@
package com.study.course_registration.controller;
package com.study.course_registration.web.controller;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.catchThrowableOfType;
@@ -1,4 +1,4 @@
package com.study.course_registration.controller;
package com.study.course_registration.web.controller;
import static org.assertj.core.api.Assertions.assertThat;