refactor: 테스트 GWT로 통일해서 사용할 수 있도록 구성 및 서브에이전트 파일 수정

This commit is contained in:
donghyeon-ka
2026-09-21 15:31:30 +09:00
parent 62bc656c08
commit 1bbc6a6f76
115 changed files with 4899 additions and 1857 deletions
@@ -0,0 +1,11 @@
package com.study.course_registration.config;
import java.time.DayOfWeek;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
@Converter(autoApply = true)
public class DayOfWeekConverter implements AttributeConverter<DayOfWeek, Integer> {
public Integer convertToDatabaseColumn(DayOfWeek day) { return day == null ? null : day.getValue(); }
public DayOfWeek convertToEntityAttribute(Integer value) { return value == null ? null : DayOfWeek.of(value); }
}
@@ -1,10 +1,19 @@
package com.study.course_registration.config;
import java.time.Clock;
import java.util.Optional;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.auditing.DateTimeProvider;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
import org.springframework.scheduling.annotation.EnableScheduling;
@Configuration
@EnableJpaAuditing
@Configuration
@EnableJpaAuditing(dateTimeProviderRef = "auditingDateTimeProvider")
@EnableScheduling
public class JpaConfig {
@Bean
DateTimeProvider auditingDateTimeProvider(Clock clock) {
return () -> Optional.of(clock.instant());
}
}
@@ -0,0 +1,37 @@
package com.study.course_registration.config;
import java.util.Arrays;
import java.util.Set;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
@Configuration(proxyBeanMethods = false)
public class RuntimeProfileConfig {
private static final Set<String> ENVIRONMENT_PROFILES = Set.of("local", "dev", "prod");
private static final String TEST_PROFILE = "test";
@Bean
static BeanFactoryPostProcessor runtimeProfileGuard(Environment environment) {
requireValidProfiles(environment.getActiveProfiles());
return beanFactory -> {};
}
static void requireValidProfiles(String[] activeProfiles) {
long environmentCount = Arrays.stream(activeProfiles)
.filter(ENVIRONMENT_PROFILES::contains)
.count();
boolean testActive = Arrays.asList(activeProfiles).contains(TEST_PROFILE);
if (testActive && environmentCount == 0) {
return;
}
if (!testActive && environmentCount == 1) {
return;
}
throw new IllegalStateException(
"local, dev, prod 중 정확히 하나의 환경 profile을 활성화해야 하며 test와 함께 사용할 수 없습니다.");
}
}
@@ -0,0 +1,11 @@
package com.study.course_registration.config;
import com.study.course_registration.enums.UserRole;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
@Converter(autoApply = true)
public class UserRoleConverter implements AttributeConverter<UserRole, String> {
public String convertToDatabaseColumn(UserRole role) { return role == null ? null : role.name(); }
public UserRole convertToEntityAttribute(String value) { return value == null ? null : UserRole.valueOf(value); }
}
@@ -7,6 +7,7 @@ import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseStatus;
@@ -47,8 +48,9 @@ public class CourseRegistrationController {
})
public CourseRegistrationResponse register(
@PathVariable String userId,
@RequestHeader(name = "Idempotency-Key", required = false) String idempotencyKey,
@Valid @RequestBody CourseRegistrationRequest request) {
return courseRegistrationService.register(userId, request);
return courseRegistrationService.register(userId, request, idempotencyKey);
}
@GetMapping
@@ -32,7 +32,7 @@ public class LessonController {
public LessonListResponse getLessons(
@RequestParam(required = false) String semesterId,
@RequestParam(required = false) String subjectId,
@RequestParam(defaultValue = "0") @Min(0) int page,
@RequestParam(defaultValue = "0") @Min(0) @Max(1_000_000) int page,
@RequestParam(defaultValue = "20") @Min(1) @Max(100) int size) {
return lessonQueryService.getLessons(semesterId, subjectId, page, size);
}
@@ -1,24 +0,0 @@
package com.study.course_registration.entity;
import java.time.Instant;
import jakarta.persistence.MappedSuperclass;
import lombok.Getter;
@MappedSuperclass
@Getter
public class BaseDeleteEntity {
private Instant deletedAt;
public void delete() {
this.deletedAt = Instant.now();
}
public void restore() {
this.deletedAt = null;
}
public boolean isDeleted() {
return this.deletedAt != null;
}
}
@@ -1,11 +1,11 @@
package com.study.course_registration.entity;
import java.util.UUID;
import jakarta.persistence.Column;
import jakarta.persistence.Id;
import jakarta.persistence.MappedSuperclass;
import jakarta.persistence.PrePersist;
import jakarta.persistence.Version;
import lombok.Getter;
@Getter
@@ -15,17 +15,15 @@ public abstract class BaseEntity {
@Column(length = 36, nullable = false, updatable = false)
private String id;
protected BaseEntity() {
}
@Version
@Column(nullable = false)
private Long version;
protected BaseEntity(String id) {
this.id = id;
}
protected BaseEntity() {}
protected BaseEntity(String id) { this.id = id; }
@PrePersist
protected void assignId() {
if (id == null) {
id = UUID.randomUUID().toString();
}
if (id == null) id = UUID.randomUUID().toString();
}
}
@@ -6,18 +6,17 @@ import com.study.course_registration.enums.UserRole;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.FetchType;
import jakarta.persistence.ForeignKey;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@NoArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
@Table(name = "lessons")
public class Lesson extends BaseTimeZoneEntity {
@@ -42,7 +41,6 @@ public class Lesson extends BaseTimeZoneEntity {
@Column(name = "min_grade")
private Long minGrade;
@Enumerated(EnumType.STRING)
@Column(name = "allowed_role")
private UserRole allowedRole;
@@ -6,26 +6,24 @@ import java.util.Objects;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.FetchType;
import jakarta.persistence.ForeignKey;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@Getter
@NoArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Table(name = "lesson_schedules")
public class LessonSchedule extends BaseTimeZoneEntity {
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "lesson_id", nullable = false, foreignKey = @ForeignKey(name = "fk_schedule_lesson"))
private Lesson lesson;
@Enumerated(EnumType.STRING)
@Column(nullable = false, length = 16)
private DayOfWeek dayOfWeek;
@@ -3,11 +3,12 @@ package com.study.course_registration.entity;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@NoArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
@Table(name = "professors")
public class Professor extends BaseTimeZoneEntity {
@@ -0,0 +1,67 @@
package com.study.course_registration.entity;
import java.time.Instant;
import java.util.Objects;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.ForeignKey;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Table(name = "registration_idempotencies",
uniqueConstraints = @UniqueConstraint(
name = "uk_registration_idempotency",
columnNames = {"user_id", "idempotency_key"}))
public class RegistrationIdempotency extends BaseCreateEntity {
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "user_id", nullable = false, foreignKey = @ForeignKey(name = "fk_idempotency_user"))
private User user;
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "lesson_id", nullable = false, foreignKey = @ForeignKey(name = "fk_idempotency_lesson"))
private Lesson lesson;
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(
name = "registration_id",
nullable = false,
foreignKey = @ForeignKey(name = "fk_idempotency_registration"))
private UserLesson registration;
@Column(name = "idempotency_key", nullable = false, length = 100)
private String idempotencyKey;
@Column(name = "total_credits", nullable = false)
private Integer totalCredits;
@Column(name = "expires_at", nullable = false)
private Instant expiresAt;
public RegistrationIdempotency(
User user,
Lesson lesson,
UserLesson registration,
String idempotencyKey,
Integer totalCredits,
Instant expiresAt) {
this.user = Objects.requireNonNull(user, "user");
this.lesson = Objects.requireNonNull(lesson, "lesson");
this.registration = Objects.requireNonNull(registration, "registration");
if (idempotencyKey == null || idempotencyKey.isBlank() || idempotencyKey.length() > 100) {
throw new IllegalArgumentException("idempotencyKey length must be 1..100");
}
this.idempotencyKey = idempotencyKey;
this.totalCredits = Objects.requireNonNull(totalCredits, "totalCredits");
this.expiresAt = Objects.requireNonNull(expiresAt, "expiresAt");
}
}
@@ -8,12 +8,13 @@ import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@Getter
@NoArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Table(name = "semesters", uniqueConstraints = @UniqueConstraint(name = "uk_semester_name", columnNames = "name"))
public class Semester extends BaseTimeZoneEntity {
@Column(nullable = false)
@@ -4,11 +4,12 @@ import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
import jakarta.persistence.UniqueConstraint;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@NoArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
@Table(name = "subjects", uniqueConstraints = @UniqueConstraint(name = "uk_subject_code", columnNames = "code"))
public class Subject extends BaseTimeZoneEntity {
@@ -6,15 +6,14 @@ import com.study.course_registration.enums.UserRole;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.Table;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@Getter
@NoArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Table(name = "users")
public class User extends BaseTimeZoneEntity {
@Column(nullable = false)
@@ -23,7 +22,6 @@ public class User extends BaseTimeZoneEntity {
@Column(nullable = false)
private Long grade;
@Enumerated(EnumType.STRING)
@Column(nullable = false)
private UserRole role;
@@ -10,11 +10,12 @@ import jakarta.persistence.ForeignKey;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@NoArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
@Table(name = "user_lessons")
public class UserLesson extends BaseCreateEntity {
@@ -17,8 +17,9 @@ public enum RegistrationErrorCode {
SCHEDULE_CONFLICT(HttpStatus.CONFLICT),
CREDIT_LIMIT_EXCEEDED(HttpStatus.CONFLICT),
CAPACITY_EXCEEDED(HttpStatus.CONFLICT),
ALREADY_CANCELED(HttpStatus.CONFLICT),
LOCK_TIMEOUT(HttpStatus.SERVICE_UNAVAILABLE);
IDEMPOTENCY_KEY_REUSED(HttpStatus.CONFLICT),
LOCK_TIMEOUT(HttpStatus.SERVICE_UNAVAILABLE),
INTERNAL_SERVER_ERROR(HttpStatus.INTERNAL_SERVER_ERROR);
private final HttpStatus status;
@@ -1,54 +1,55 @@
package com.study.course_registration.exception;
import java.time.Clock;
import java.util.concurrent.ThreadLocalRandom;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.PessimisticLockingFailureException;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import com.study.course_registration.enums.RegistrationErrorCode;
import jakarta.persistence.LockTimeoutException;
import jakarta.persistence.PessimisticLockException;
import jakarta.validation.ConstraintViolationException;
@RestControllerAdvice
public class GlobalExceptionHandler {
private static final Logger log=LoggerFactory.getLogger(GlobalExceptionHandler.class);
private final Clock clock;
public GlobalExceptionHandler(Clock clock) {
this.clock = clock;
}
public GlobalExceptionHandler(Clock clock) { this.clock=clock; }
@ExceptionHandler(RegistrationException.class)
ResponseEntity<ErrorResponse> handleRegistrationException(RegistrationException exception) {
return response(exception.getErrorCode(), exception.getMessage());
}
ResponseEntity<ErrorResponse> registration(RegistrationException e) { return response(e.getErrorCode(),e.getMessage()); }
@ExceptionHandler(MethodArgumentNotValidException.class)
ResponseEntity<ErrorResponse> handleValidation(MethodArgumentNotValidException exception) {
String message = exception.getBindingResult().getFieldErrors().stream()
.findFirst()
.map(error -> error.getField() + ": " + error.getDefaultMessage())
.orElse("요청 값이 올바르지 않습니다.");
return response(RegistrationErrorCode.VALIDATION_ERROR, message);
ResponseEntity<ErrorResponse> validation(MethodArgumentNotValidException e) {
String message=e.getBindingResult().getFieldErrors().stream().findFirst()
.map(x -> x.getField()+": "+x.getDefaultMessage()).orElse("요청 값이 올바르지 않습니다.");
return response(RegistrationErrorCode.VALIDATION_ERROR,message);
}
@ExceptionHandler({ConstraintViolationException.class, HttpMessageNotReadableException.class})
ResponseEntity<ErrorResponse> handleBadRequest(Exception exception) {
return response(RegistrationErrorCode.VALIDATION_ERROR, "요청 값이 올바르지 않습니다.");
@ExceptionHandler({ConstraintViolationException.class,HttpMessageNotReadableException.class})
ResponseEntity<ErrorResponse> badRequest(Exception e) { return response(RegistrationErrorCode.VALIDATION_ERROR,"요청 값이 올바르지 않습니다."); }
@ExceptionHandler({LockTimeoutException.class,PessimisticLockException.class,PessimisticLockingFailureException.class})
ResponseEntity<ErrorResponse> handleLockTimeout(Exception e) {
String retryAfter = Integer.toString(ThreadLocalRandom.current().nextInt(1, 4));
return ResponseEntity.status(RegistrationErrorCode.LOCK_TIMEOUT.getStatus()).header(HttpHeaders.RETRY_AFTER, retryAfter)
.body(body(RegistrationErrorCode.LOCK_TIMEOUT,"다른 요청이 처리 중입니다. 잠시 후 다시 시도해 주세요."));
}
@ExceptionHandler({LockTimeoutException.class, PessimisticLockException.class, PessimisticLockingFailureException.class})
ResponseEntity<ErrorResponse> handleLockTimeout(Exception exception) {
return response(RegistrationErrorCode.LOCK_TIMEOUT, "다른 요청이 처리 중입니다. 잠시 후 다시 시도해 주세요.");
@ExceptionHandler(Exception.class)
ResponseEntity<ErrorResponse> handleUnexpected(Exception e) {
log.error("Unhandled request failure",e);
return response(RegistrationErrorCode.INTERNAL_SERVER_ERROR,"서버 내부 오류가 발생했습니다.");
}
private ResponseEntity<ErrorResponse> response(RegistrationErrorCode code, String message) {
return ResponseEntity.status(code.getStatus())
.body(new ErrorResponse(code.name(), message, clock.instant()));
private ResponseEntity<ErrorResponse> response(RegistrationErrorCode code,String message) {
return ResponseEntity.status(code.getStatus()).body(body(code,message));
}
private ErrorResponse body(RegistrationErrorCode code,String message) { return new ErrorResponse(code.name(),message,clock.instant()); }
}
@@ -0,0 +1,38 @@
package com.study.course_registration.repository;
import java.time.Instant;
import java.util.Optional;
import org.springframework.data.jpa.repository.EntityGraph;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import com.study.course_registration.entity.RegistrationIdempotency;
public interface RegistrationIdempotencyRepository extends JpaRepository<RegistrationIdempotency, String> {
@EntityGraph(attributePaths = {
"user", "lesson", "lesson.subject", "registration"
})
Optional<RegistrationIdempotency> findByUser_IdAndIdempotencyKeyAndExpiresAtAfter(
String userId,
String idempotencyKey,
Instant now);
@Modifying
@Query("""
delete from RegistrationIdempotency value
where value.user.id = :userId
and value.idempotencyKey = :idempotencyKey
and value.expiresAt <= :now
""")
int deleteExpiredKey(
@Param("userId") String userId,
@Param("idempotencyKey") String idempotencyKey,
@Param("now") Instant now);
@Modifying
@Query("delete from RegistrationIdempotency value where value.expiresAt <= :now")
int deleteExpired(@Param("now") Instant now);
}
@@ -1,13 +1,17 @@
package com.study.course_registration.repository;
import java.time.Instant;
import java.time.LocalDate;
import java.util.Optional;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import com.study.course_registration.entity.Semester;
public interface SemesterRepository extends JpaRepository<Semester, String> {
Optional<Semester> findFirstByStartDateLessThanEqualAndEndDateGreaterThanEqualOrderByStartDateDesc(
List<Semester> findByStartDateLessThanEqualAndEndDateGreaterThanEqual(
LocalDate startDate, LocalDate endDate);
List<Semester> findByRegistrationStartAtLessThanEqualAndRegistrationEndAtGreaterThanEqual(
Instant startAt, Instant endAt);
}
@@ -1,14 +1,18 @@
package com.study.course_registration.seeder;
import java.time.Clock;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
@@ -19,14 +23,12 @@ import com.study.course_registration.entity.Semester;
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.repository.LessonRepository;
import com.study.course_registration.repository.LessonScheduleRepository;
import com.study.course_registration.repository.ProfessorRepository;
import com.study.course_registration.repository.SemesterRepository;
import com.study.course_registration.repository.SubjectRepository;
import com.study.course_registration.repository.UserRepository;
import com.study.course_registration.service.policy.LessonSchedulePolicy;
import jakarta.persistence.EntityManager;
@Component
@Profile({"local", "dev"})
@ConditionalOnProperty(name = "app.seed.enabled", havingValue = "true")
public class DataSeeder implements CommandLineRunner {
public static final String SEMESTER_ID = "00000000-0000-0000-0000-000000000001";
@@ -41,81 +43,77 @@ public class DataSeeder implements CommandLineRunner {
public static final String POSTGRADUATE_ONLY_ID = "40000000-0000-0000-0000-000000000006";
public static final String BOUNDARY_LESSON_ID = "40000000-0000-0000-0000-000000000007";
private final Clock clock;
private final SemesterRepository semesterRepository;
private final ProfessorRepository professorRepository;
private final SubjectRepository subjectRepository;
private final LessonRepository lessonRepository;
private final LessonScheduleRepository lessonScheduleRepository;
private final UserRepository userRepository;
private final JdbcTemplate jdbcTemplate;
private final EntityManager entityManager;
private final LessonSchedulePolicy schedulePolicy;
public DataSeeder(Clock clock,
SemesterRepository semesterRepository,
ProfessorRepository professorRepository,
SubjectRepository subjectRepository,
LessonRepository lessonRepository,
LessonScheduleRepository lessonScheduleRepository,
UserRepository userRepository) {
this.clock = clock;
this.semesterRepository = semesterRepository;
this.professorRepository = professorRepository;
this.subjectRepository = subjectRepository;
this.lessonRepository = lessonRepository;
this.lessonScheduleRepository = lessonScheduleRepository;
this.userRepository = userRepository;
public DataSeeder(JdbcTemplate jdbcTemplate, EntityManager entityManager, LessonSchedulePolicy schedulePolicy) {
this.jdbcTemplate = jdbcTemplate;
this.entityManager = entityManager;
this.schedulePolicy = schedulePolicy;
}
@Override
@Transactional
public void run(String... args) {
if (semesterRepository.existsById(SEMESTER_ID)) {
jdbcTemplate.queryForObject(
"select name from seed_locks where name = ? for update",
String.class, "demo-dataset");
if (entityManager.find(Semester.class, SEMESTER_ID) != null) {
return;
}
Instant now = clock.instant();
LocalDate today = LocalDate.now(clock);
Semester semester = semesterRepository.save(new Semester(
SEMESTER_ID, "2026-1", today.minusDays(30), today.plusDays(120),
now.minusSeconds(86_400), now.plusSeconds(7 * 86_400), 18));
Map<String, Semester> semesters = new LinkedHashMap<>();
for (SeedTable.Row row : SeedTable.read("seed/demo/semesters.tsv")) {
Semester semester = new Semester(row.text("id"), row.text("name"),
LocalDate.parse(row.text("startDate")), LocalDate.parse(row.text("endDate")),
Instant.parse(row.text("registrationStartAt")), Instant.parse(row.text("registrationEndAt")),
row.integer("maxCredits"));
entityManager.persist(semester);
semesters.put(semester.getId(), semester);
}
List<Professor> professors = professorRepository.saveAll(List.of(
new Professor("10000000-0000-0000-0000-000000000001", "김영한"),
new Professor("10000000-0000-0000-0000-000000000002", "최태영"),
new Professor("10000000-0000-0000-0000-000000000003", "조재한")));
Map<String, Professor> professors = new LinkedHashMap<>();
for (SeedTable.Row row : SeedTable.read("seed/demo/professors.tsv")) {
Professor professor = new Professor(row.text("id"), row.text("name"));
entityManager.persist(professor);
professors.put(professor.getId(), professor);
}
List<Subject> subjects = subjectRepository.saveAll(List.of(
new Subject("20000000-0000-0000-0000-000000000001", "자바 프로그래밍", "CS201", "자바 프로그래밍 기초", 3),
new Subject("20000000-0000-0000-0000-000000000002", "자료구조", "CS202", "자료구조 및 알고리즘", 3),
new Subject("20000000-0000-0000-0000-000000000003", "데이터베이스", "CS203", "데이터베이스 시스템", 3),
new Subject("20000000-0000-0000-0000-000000000004", "컴퓨터 네트워크", "CS204", "네트워크 기초", 3),
new Subject("20000000-0000-0000-0000-000000000005", "운영체제", "CS301", "운영체제 핵심", 3),
new Subject("20000000-0000-0000-0000-000000000006", "대학원 세미나", "CS401", "대학원 전용 세미나", 3)));
Map<String, Subject> subjects = new LinkedHashMap<>();
for (SeedTable.Row row : SeedTable.read("seed/demo/subjects.tsv")) {
Subject subject = new Subject(row.text("id"), row.text("name"), row.text("code"),
row.text("description"), row.integer("credit"));
entityManager.persist(subject);
subjects.put(subject.getId(), subject);
}
Lesson data01 = new Lesson(DATA_STRUCTURES_01_ID, "자료구조 01분반", subjects.get(1), professors.get(0), semester, 30, null, null);
Lesson data02 = new Lesson(DATA_STRUCTURES_02_ID, "자료구조 02분반", subjects.get(1), professors.get(1), semester, 30, null, null);
Lesson os = new Lesson(OVERLAP_OS_ID, "운영체제", subjects.get(4), professors.get(1), semester, 30, null, null);
Lesson capacityOne = new Lesson(CAPACITY_ONE_ID, "데이터베이스 소수정예", subjects.get(2), professors.get(2), semester, 1, null, null);
Lesson minGrade = new Lesson(MIN_GRADE_ID, "고급 네트워크", subjects.get(3), professors.get(2), semester, 30, 3L, null);
Lesson postgraduate = new Lesson(POSTGRADUATE_ONLY_ID, "대학원 세미나", subjects.get(5), professors.get(0), semester, 20, null, UserRole.POSTGRADUATE);
Lesson boundary = new Lesson(BOUNDARY_LESSON_ID, "자바 프로그래밍", subjects.get(0), professors.get(0), semester, 30, null, null);
lessonRepository.saveAll(List.of(data01, data02, os, capacityOne, minGrade, postgraduate, boundary));
for (SeedTable.Row row : SeedTable.read("seed/demo/users.tsv")) {
entityManager.persist(new User(row.text("id"), row.text("name"), row.longValue("grade"),
UserRole.valueOf(row.text("role"))));
}
lessonScheduleRepository.saveAll(List.of(
schedule("50000000-0000-0000-0000-000000000001", data01, DayOfWeek.MONDAY, 9, 11),
schedule("50000000-0000-0000-0000-000000000002", data02, DayOfWeek.TUESDAY, 9, 11),
schedule("50000000-0000-0000-0000-000000000003", os, DayOfWeek.MONDAY, 10, 12),
schedule("50000000-0000-0000-0000-000000000004", capacityOne, DayOfWeek.WEDNESDAY, 9, 11),
schedule("50000000-0000-0000-0000-000000000005", minGrade, DayOfWeek.THURSDAY, 9, 11),
schedule("50000000-0000-0000-0000-000000000006", postgraduate, DayOfWeek.FRIDAY, 9, 11),
schedule("50000000-0000-0000-0000-000000000007", boundary, DayOfWeek.MONDAY, 11, 13)));
Map<String, Lesson> lessons = new LinkedHashMap<>();
for (SeedTable.Row row : SeedTable.read("seed/demo/lessons.tsv")) {
String minGrade = row.nullable("minGrade");
String allowedRole = row.nullable("allowedRole");
Lesson lesson = new Lesson(row.text("id"), row.text("name"),
subjects.get(row.text("subjectId")), professors.get(row.text("professorId")),
semesters.get(row.text("semesterId")), row.integer("capacity"),
minGrade == null ? null : Long.parseLong(minGrade),
allowedRole == null ? null : UserRole.valueOf(allowedRole));
entityManager.persist(lesson);
lessons.put(lesson.getId(), lesson);
}
userRepository.saveAll(List.of(
new User(STUDENT_GRADE_1_ID, "학생1", 1L, UserRole.STUDENT),
new User(STUDENT_GRADE_2_ID, "학생2", 2L, UserRole.STUDENT),
new User(POSTGRADUATE_ID, "대학원생", 3L, UserRole.POSTGRADUATE)));
List<LessonSchedule> schedules = new ArrayList<>();
for (SeedTable.Row row : SeedTable.read("seed/demo/schedules.tsv")) {
schedules.add(new LessonSchedule(row.text("id"), lessons.get(row.text("lessonId")),
DayOfWeek.valueOf(row.text("dayOfWeek")), LocalTime.parse(row.text("startTime")),
LocalTime.parse(row.text("endTime"))));
}
schedulePolicy.validate(schedules);
schedules.forEach(entityManager::persist);
}
private static LessonSchedule schedule(String id, Lesson lesson, DayOfWeek day, int startHour, int endHour) {
return new LessonSchedule(id, lesson, day, LocalTime.of(startHour, 0), LocalTime.of(endHour, 0));
}
}
@@ -0,0 +1,47 @@
package com.study.course_registration.seeder;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
import java.util.stream.IntStream;
import java.util.stream.Collectors;
import org.springframework.core.io.ClassPathResource;
final class SeedTable {
private SeedTable() {}
static List<Row> read(String resource) {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(
new ClassPathResource(resource).getInputStream(), StandardCharsets.UTF_8))) {
List<String> lines = reader.lines().filter(line -> !line.isBlank() && !line.startsWith("#")).toList();
String[] headers = lines.getFirst().split("\t", -1);
return lines.stream().skip(1).map(line -> row(headers, line)).toList();
} catch (IOException exception) {
throw new IllegalStateException("seed data를 읽을 수 없습니다: " + resource, exception);
}
}
private static Row row(String[] headers, String line) {
String[] values = line.split("\t", -1);
if (headers.length != values.length) {
throw new IllegalStateException("seed column 수가 맞지 않습니다: " + line);
}
Map<String, String> columns = IntStream.range(0, headers.length)
.boxed().collect(Collectors.toMap(index -> headers[index], index -> values[index]));
return new Row(columns);
}
record Row(Map<String, String> columns) {
String text(String name) { return columns.get(name); }
String nullable(String name) {
String value = text(name);
return value == null || value.isBlank() ? null : value;
}
int integer(String name) { return Integer.parseInt(text(name)); }
long longValue(String name) { return Long.parseLong(text(name)); }
}
}
@@ -1,17 +1,17 @@
package com.study.course_registration.service;
import java.time.Clock;
import java.time.LocalDate;
import java.time.Instant;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.study.course_registration.dto.ScheduleResponse;
import com.study.course_registration.dto.registration.CourseRegistrationRequest;
import com.study.course_registration.dto.registration.CourseRegistrationResponse;
@@ -19,165 +19,162 @@ import com.study.course_registration.dto.registration.RegistrationItemResponse;
import com.study.course_registration.dto.registration.RegistrationListResponse;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.entity.RegistrationIdempotency;
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.enums.RegistrationErrorCode;
import com.study.course_registration.exception.RegistrationException;
import com.study.course_registration.repository.LessonRepository;
import com.study.course_registration.repository.LessonScheduleRepository;
import com.study.course_registration.repository.SemesterRepository;
import com.study.course_registration.repository.RegistrationIdempotencyRepository;
import com.study.course_registration.repository.UserLessonRepository;
import com.study.course_registration.repository.UserRepository;
import com.study.course_registration.service.lock.RegistrationLockManager;
import com.study.course_registration.service.lock.RegistrationLockManager.LockedRegistration;
import com.study.course_registration.service.policy.RegistrationValidator;
@Service
public class CourseRegistrationService {
private final Clock clock;
private final UserRepository userRepository;
private final LessonRepository lessonRepository;
private final SemesterRepository semesterRepository;
private final LessonScheduleRepository lessonScheduleRepository;
private final UserLessonRepository userLessonRepository;
private final RegistrationIdempotencyRepository idempotencies;
private final RegistrationValidator validator;
private final SemesterResolver semesterResolver;
private final RegistrationLockManager lockManager;
private final long idempotencyTtlSeconds;
public CourseRegistrationService(Clock clock,
UserRepository userRepository,
LessonRepository lessonRepository,
SemesterRepository semesterRepository,
LessonScheduleRepository lessonScheduleRepository,
UserLessonRepository userLessonRepository,
RegistrationValidator validator) {
public CourseRegistrationService(Clock clock, UserRepository userRepository,
LessonScheduleRepository lessonScheduleRepository, UserLessonRepository userLessonRepository,
RegistrationIdempotencyRepository idempotencies, RegistrationValidator validator,
SemesterResolver semesterResolver, RegistrationLockManager lockManager,
@Value("${app.idempotency.ttl-seconds:86400}") long idempotencyTtlSeconds) {
this.clock = clock;
this.userRepository = userRepository;
this.lessonRepository = lessonRepository;
this.semesterRepository = semesterRepository;
this.lessonScheduleRepository = lessonScheduleRepository;
this.userLessonRepository = userLessonRepository;
this.idempotencies = idempotencies;
this.validator = validator;
this.semesterResolver = semesterResolver;
this.lockManager = lockManager;
this.idempotencyTtlSeconds = idempotencyTtlSeconds;
}
@Transactional
public CourseRegistrationResponse register(String userId, CourseRegistrationRequest request) {
User user = userRepository.findById(userId)
.orElseThrow(() -> error(RegistrationErrorCode.USER_NOT_FOUND, "사용자를 찾을 수 없습니다."));
Lesson lesson = lessonRepository.findById(request.lessonId())
.orElseThrow(() -> error(RegistrationErrorCode.LESSON_NOT_FOUND, "강의를 찾을 수 없습니다."));
return register(userId, request, null);
}
var now = clock.instant();
validator.validatePreconditions(user, lesson, now);
@Transactional
public CourseRegistrationResponse register(String userId, CourseRegistrationRequest request, String idempotencyKey) {
LockedRegistration locked = lockManager.lock(userId, request.lessonId());
// Lock order is a system invariant: User -> Lesson.
User lockedUser = userRepository.findByIdForUpdate(userId)
.orElseThrow(() -> error(RegistrationErrorCode.USER_NOT_FOUND, "사용자를 찾을 수 없습니다."));
Lesson lockedLesson = lessonRepository.findByIdForUpdate(request.lessonId())
.orElseThrow(() -> error(RegistrationErrorCode.LESSON_NOT_FOUND, "강의를 찾을 수 없습니다."));
String normalizedKey = normalizeIdempotencyKey(idempotencyKey);
Instant requestTime = clock.instant();
if (normalizedKey != null) {
idempotencies.deleteExpiredKey(userId, normalizedKey, requestTime);
Optional<RegistrationIdempotency> previous =
idempotencies.findByUser_IdAndIdempotencyKeyAndExpiresAtAfter(
userId, normalizedKey, requestTime);
if (previous.isPresent()) {
RegistrationIdempotency stored = previous.get();
if (!stored.getLesson().getId().equals(request.lessonId())) {
throw error(RegistrationErrorCode.IDEMPOTENCY_KEY_REUSED,
"동일한 Idempotency-Key를 다른 강의에 사용할 수 없습니다.");
}
return response(stored.getRegistration(), stored.getUser(), stored.getLesson(), stored.getTotalCredits());
}
}
List<UserLesson> activeRegistrations = userLessonRepository.findActiveByUserIdAndSemesterId(
lockedUser.getId(), lockedLesson.getSemester().getId());
Map<String, List<LessonSchedule>> schedules = loadSchedules(activeRegistrations, lockedLesson);
long enrolledCount = userLessonRepository.countByLesson_IdAndCanceledAtIsNull(lockedLesson.getId());
validator.validatePreconditions(locked.user(), locked.lesson(), requestTime);
validator.validateLocked(lockedLesson, activeRegistrations, schedules, enrolledCount);
int totalCredits = validator.totalCreditsAfter(lockedLesson, activeRegistrations);
List<UserLesson> active = userLessonRepository.findActiveByUserIdAndSemesterId(
locked.user().getId(), locked.lesson().getSemester().getId());
Map<String, List<LessonSchedule>> schedules = loadSchedules(active, locked.lesson());
long enrolled = userLessonRepository.countByLesson_IdAndCanceledAtIsNull(locked.lesson().getId());
UserLesson registration = userLessonRepository.saveAndFlush(new UserLesson(lockedUser, lockedLesson));
return new CourseRegistrationResponse(
registration.getId(),
lockedUser.getId(),
lockedLesson.getId(),
lockedLesson.getName(),
lockedLesson.getSubject().getCode(),
lockedLesson.getSubject().getCredit(),
registration.getCreatedAt(),
totalCredits);
validator.validateLocked(locked.lesson(), active, schedules, enrolled);
validator.validateRegistrationPeriod(locked.lesson(), clock.instant());
int totalCredits = validator.totalCreditsAfter(locked.lesson(), active);
UserLesson registration = userLessonRepository.saveAndFlush(new UserLesson(locked.user(), locked.lesson()));
if (normalizedKey != null) {
idempotencies.saveAndFlush(new RegistrationIdempotency(
locked.user(),
locked.lesson(),
registration,
normalizedKey,
totalCredits,
requestTime.plusSeconds(idempotencyTtlSeconds)));
}
return response(registration, locked.user(), locked.lesson(), totalCredits);
}
@Transactional(readOnly = true)
public RegistrationListResponse getRegistrations(String userId, String semesterId) {
if (!userRepository.existsById(userId)) {
throw error(RegistrationErrorCode.USER_NOT_FOUND, "사용자를 찾을 수 없습니다.");
}
Semester semester = resolveSemester(semesterId);
List<UserLesson> activeRegistrations = userLessonRepository.findActiveByUserIdAndSemesterId(userId, semester.getId());
Set<String> lessonIds = activeRegistrations.stream()
.map(UserLesson::getLesson)
.map(Lesson::getId)
if (!userRepository.existsById(userId)) throw error(RegistrationErrorCode.USER_NOT_FOUND, "사용자를 찾을 수 없습니다.");
Semester semester = semesterResolver.resolve(semesterId);
List<UserLesson> active = userLessonRepository.findActiveByUserIdAndSemesterId(userId, semester.getId());
Set<String> lessonIds = active.stream().map(UserLesson::getLesson).map(Lesson::getId)
.collect(Collectors.toCollection(LinkedHashSet::new));
Map<String, List<LessonSchedule>> schedulesByLesson = groupSchedules(
lessonIds.isEmpty() ? List.of() : lessonScheduleRepository.findByLesson_IdInOrderByDayOfWeekAscStartTimeAsc(lessonIds));
List<RegistrationItemResponse> items = activeRegistrations.stream()
.map(registration -> {
Lesson lesson = registration.getLesson();
List<ScheduleResponse> schedules = schedulesByLesson.getOrDefault(lesson.getId(), List.of()).stream()
.map(ScheduleResponse::from)
.toList();
return new RegistrationItemResponse(
registration.getId(), lesson.getId(), lesson.getName(),
lesson.getSubject().getCode(), lesson.getSubject().getName(), lesson.getSubject().getCredit(),
lesson.getProfessor().getName(), schedules, registration.getCreatedAt());
})
.toList();
return new RegistrationListResponse(
userId, semester.getId(), semester.getName(), validator.currentCredits(activeRegistrations),
semester.getMaxCredits(), items);
Map<String,List<LessonSchedule>> schedules = groupSchedules(lessonIds.isEmpty() ? List.of()
: lessonScheduleRepository.findByLesson_IdInOrderByDayOfWeekAscStartTimeAsc(lessonIds));
List<RegistrationItemResponse> items = active.stream().map(registration -> {
Lesson lesson=registration.getLesson();
return new RegistrationItemResponse(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(ScheduleResponse::from).toList(), registration.getCreatedAt());
}).toList();
return new RegistrationListResponse(userId, semester.getId(), semester.getName(),
validator.currentCredits(active), semester.getMaxCredits(), items);
}
@Transactional
public void cancel(String userId, String registrationId) {
UserLessonRepository.RegistrationTarget target = userLessonRepository.findTargetById(registrationId)
.orElseThrow(() -> error(RegistrationErrorCode.REGISTRATION_NOT_FOUND, "수강신청 건을 찾을 수 없습니다."));
if (!target.getUserId().equals(userId)) {
throw error(RegistrationErrorCode.REGISTRATION_FORBIDDEN, "다른 사용자의 수강신청은 취소할 수 없습니다.");
}
// Mutation paths use the same fixed lock order as registration.
userRepository.findByIdForUpdate(userId)
.orElseThrow(() -> error(RegistrationErrorCode.USER_NOT_FOUND, "사용자를 찾을 수 없습니다."));
Lesson lesson = lessonRepository.findByIdForUpdate(target.getLessonId())
.orElseThrow(() -> error(RegistrationErrorCode.LESSON_NOT_FOUND, "강의를 찾을 수 없습니다."));
if (!target.getUserId().equals(userId)) throw error(RegistrationErrorCode.REGISTRATION_FORBIDDEN, "다른 사용자의 수강신청은 취소할 수 없습니다.");
LockedRegistration locked = lockManager.lock(userId, target.getLessonId());
UserLesson registration = userLessonRepository.findById(registrationId)
.orElseThrow(() -> error(RegistrationErrorCode.REGISTRATION_NOT_FOUND, "수강신청 건을 찾을 수 없습니다."));
if (registration.isCanceled()) {
throw error(RegistrationErrorCode.ALREADY_CANCELED, "이미 취소된 수강신청입니다.");
}
var now = clock.instant();
validator.validateRegistrationPeriod(lesson, now);
if (registration.isCanceled()) return;
Instant now = clock.instant();
validator.validateRegistrationPeriod(locked.lesson(), now);
registration.cancel(now);
}
private Semester resolveSemester(String semesterId) {
if (semesterId != null && !semesterId.isBlank()) {
return semesterRepository.findById(semesterId)
.orElseThrow(() -> error(RegistrationErrorCode.SEMESTER_NOT_FOUND, "학기를 찾을 수 없습니다."));
private CourseRegistrationResponse response(
UserLesson registration,
User user,
Lesson lesson,
int totalCredits) {
return new CourseRegistrationResponse(
registration.getId(), user.getId(), lesson.getId(), lesson.getName(),
lesson.getSubject().getCode(), lesson.getSubject().getCredit(),
registration.getCreatedAt(), totalCredits);
}
private static String normalizeIdempotencyKey(String value) {
if (value == null || value.isBlank()) return null;
String normalized = value.trim();
if (normalized.length() > 100) {
throw error(RegistrationErrorCode.VALIDATION_ERROR, "Idempotency-Key는 100자 이하여야 합니다.");
}
LocalDate today = LocalDate.now(clock);
return semesterRepository
.findFirstByStartDateLessThanEqualAndEndDateGreaterThanEqualOrderByStartDateDesc(today, today)
.orElseThrow(() -> error(RegistrationErrorCode.SEMESTER_NOT_FOUND, "현재 진행 중인 학기를 찾을 수 없습니다."));
return normalized;
}
private Map<String, List<LessonSchedule>> loadSchedules(List<UserLesson> registrations, Lesson candidate) {
Set<String> lessonIds = registrations.stream()
.map(UserLesson::getLesson)
.map(Lesson::getId)
private Map<String,List<LessonSchedule>> loadSchedules(List<UserLesson> registrations, Lesson candidate) {
Set<String> ids=registrations.stream().map(UserLesson::getLesson).map(Lesson::getId)
.collect(Collectors.toCollection(LinkedHashSet::new));
lessonIds.add(candidate.getId());
return groupSchedules(lessonScheduleRepository.findByLesson_IdInOrderByDayOfWeekAscStartTimeAsc(lessonIds));
ids.add(candidate.getId());
return groupSchedules(lessonScheduleRepository.findByLesson_IdInOrderByDayOfWeekAscStartTimeAsc(ids));
}
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 RegistrationException error(RegistrationErrorCode code, String message) {
return new RegistrationException(code, message);
private static Map<String,List<LessonSchedule>> groupSchedules(List<LessonSchedule> schedules) {
return schedules.stream().collect(Collectors.groupingBy(s -> s.getLesson().getId(),LinkedHashMap::new,Collectors.toList()));
}
private static RegistrationException error(RegistrationErrorCode code,String message) { return new RegistrationException(code,message); }
}
@@ -0,0 +1,26 @@
package com.study.course_registration.service;
import java.time.Clock;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.study.course_registration.repository.RegistrationIdempotencyRepository;
@Component
public class IdempotencyRetentionJob {
private final Clock clock;
private final RegistrationIdempotencyRepository repository;
public IdempotencyRetentionJob(Clock clock, RegistrationIdempotencyRepository repository) {
this.clock = clock;
this.repository = repository;
}
@Scheduled(fixedDelayString = "${app.idempotency.cleanup-delay-ms:3600000}")
@Transactional
public void cleanup() {
repository.deleteExpired(clock.instant());
}
}
@@ -1,7 +1,5 @@
package com.study.course_registration.service;
import java.time.Clock;
import java.time.LocalDate;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@@ -25,32 +23,28 @@ import com.study.course_registration.enums.RegistrationErrorCode;
import com.study.course_registration.exception.RegistrationException;
import com.study.course_registration.repository.LessonRepository;
import com.study.course_registration.repository.LessonScheduleRepository;
import com.study.course_registration.repository.SemesterRepository;
import com.study.course_registration.repository.UserLessonRepository;
@Service
@Transactional(readOnly = true)
public class LessonQueryService {
private final Clock clock;
private final LessonRepository lessonRepository;
private final LessonScheduleRepository lessonScheduleRepository;
private final UserLessonRepository userLessonRepository;
private final SemesterRepository semesterRepository;
private final SemesterResolver semesterResolver;
public LessonQueryService(Clock clock,
LessonRepository lessonRepository,
public LessonQueryService(LessonRepository lessonRepository,
LessonScheduleRepository lessonScheduleRepository,
UserLessonRepository userLessonRepository,
SemesterRepository semesterRepository) {
this.clock = clock;
SemesterResolver semesterResolver) {
this.lessonRepository = lessonRepository;
this.lessonScheduleRepository = lessonScheduleRepository;
this.userLessonRepository = userLessonRepository;
this.semesterRepository = semesterRepository;
this.semesterResolver = semesterResolver;
}
public LessonListResponse getLessons(String semesterId, String subjectId, int page, int size) {
Semester semester = resolveSemester(semesterId);
Semester semester = semesterResolver.resolve(semesterId);
Pageable pageable = PageRequest.of(page, size, Sort.by(Sort.Order.asc("name"), Sort.Order.asc("id")));
Page<Lesson> lessonPage = subjectId == null || subjectId.isBlank()
? lessonRepository.findBySemester_Id(semester.getId(), pageable)
@@ -109,16 +103,6 @@ public class LessonQueryService {
LinkedHashMap::new));
}
private Semester resolveSemester(String semesterId) {
if (semesterId != null && !semesterId.isBlank()) {
return semesterRepository.findById(semesterId)
.orElseThrow(() -> error(RegistrationErrorCode.SEMESTER_NOT_FOUND, "학기를 찾을 수 없습니다."));
}
LocalDate today = LocalDate.now(clock);
return semesterRepository.findFirstByStartDateLessThanEqualAndEndDateGreaterThanEqualOrderByStartDateDesc(today, today)
.orElseThrow(() -> error(RegistrationErrorCode.SEMESTER_NOT_FOUND, "현재 진행 중인 학기를 찾을 수 없습니다."));
}
private static RegistrationException error(RegistrationErrorCode code, String message) {
return new RegistrationException(code, message);
}
@@ -0,0 +1,57 @@
package com.study.course_registration.service;
import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.util.List;
import org.springframework.stereotype.Component;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.enums.RegistrationErrorCode;
import com.study.course_registration.exception.RegistrationException;
import com.study.course_registration.repository.SemesterRepository;
@Component
public class SemesterResolver {
private final Clock clock;
private final SemesterRepository semesterRepository;
public SemesterResolver(Clock clock, SemesterRepository semesterRepository) {
this.clock = clock;
this.semesterRepository = semesterRepository;
}
public Semester resolve(String semesterId) {
if (semesterId != null && !semesterId.isBlank()) {
return semesterRepository.findById(semesterId)
.orElseThrow(() -> notFound("학기를 찾을 수 없습니다."));
}
Instant now = clock.instant();
List<Semester> registrationSemesters =
semesterRepository.findByRegistrationStartAtLessThanEqualAndRegistrationEndAtGreaterThanEqual(
now, now);
if (registrationSemesters.size() > 1) {
throw new IllegalStateException("동시에 두 개 이상의 수강신청 학기가 활성화되어 있습니다.");
}
if (registrationSemesters.size() == 1) {
return registrationSemesters.getFirst();
}
LocalDate today = LocalDate.now(clock);
List<Semester> academicSemesters =
semesterRepository.findByStartDateLessThanEqualAndEndDateGreaterThanEqual(today, today);
if (academicSemesters.size() > 1) {
throw new IllegalStateException("동시에 두 개 이상의 학기가 진행 중입니다.");
}
if (academicSemesters.size() == 1) {
return academicSemesters.getFirst();
}
throw notFound("현재 수강 가능한 학기를 찾을 수 없습니다.");
}
private static RegistrationException notFound(String message) {
return new RegistrationException(RegistrationErrorCode.SEMESTER_NOT_FOUND, message);
}
}
@@ -0,0 +1,30 @@
package com.study.course_registration.service.lock;
import org.springframework.stereotype.Component;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.User;
import com.study.course_registration.enums.RegistrationErrorCode;
import com.study.course_registration.exception.RegistrationException;
import com.study.course_registration.repository.LessonRepository;
import com.study.course_registration.repository.UserRepository;
@Component
public class RegistrationLockManager {
private final UserRepository userRepository;
private final LessonRepository lessonRepository;
public RegistrationLockManager(UserRepository userRepository, LessonRepository lessonRepository) {
this.userRepository = userRepository;
this.lessonRepository = lessonRepository;
}
public LockedRegistration lock(String userId, String lessonId) {
User user = userRepository.findByIdForUpdate(userId)
.orElseThrow(() -> new RegistrationException(RegistrationErrorCode.USER_NOT_FOUND, "사용자를 찾을 수 없습니다."));
Lesson lesson = lessonRepository.findByIdForUpdate(lessonId)
.orElseThrow(() -> new RegistrationException(RegistrationErrorCode.LESSON_NOT_FOUND, "강의를 찾을 수 없습니다."));
return new LockedRegistration(user, lesson);
}
public record LockedRegistration(User user, Lesson lesson) {}
}
@@ -0,0 +1,34 @@
package com.study.course_registration.service.policy;
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;
@Component
public 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));
for (List<LessonSchedule> 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))) {
throw new IllegalArgumentException("같은 강의의 시간표가 겹칩니다.");
}
}
}
}
}
}
@@ -55,8 +55,14 @@ public class RegistrationValidator {
}
List<LessonSchedule> candidateSchedules = schedulesByLessonId.getOrDefault(lesson.getId(), List.of());
if (candidateSchedules.isEmpty()) {
throw error(RegistrationErrorCode.INTERNAL_SERVER_ERROR, "강의 시간표가 없습니다.");
}
for (UserLesson registration : activeRegistrations) {
List<LessonSchedule> existingSchedules = schedulesByLessonId.getOrDefault(registration.getLesson().getId(), List.of());
if (existingSchedules.isEmpty()) {
throw error(RegistrationErrorCode.INTERNAL_SERVER_ERROR, "기존 신청 강의 시간표가 없습니다.");
}
for (LessonSchedule candidate : candidateSchedules) {
for (LessonSchedule existing : existingSchedules) {
if (scheduleConflictChecker.overlaps(candidate, existing)) {
+7 -2
View File
@@ -1,11 +1,16 @@
server:
address: ${SERVER_ADDRESS:0.0.0.0}
spring:
datasource:
url: jdbc:postgresql://${DB_HOST:localhost}:${DB_PORT:5432}/${DB_NAME:course_registration}
username: ${DB_USERNAME:course}
password: ${DB_PASSWORD:course}
hikari:
connection-init-sql: SET lock_timeout TO '3s'
flyway:
locations: classpath:db/migration/postgresql
jpa:
hibernate:
ddl-auto: update
show-sql: ${JPA_SHOW_SQL:false}
h2:
console:
+5 -2
View File
@@ -1,12 +1,15 @@
server:
address: 127.0.0.1
spring:
datasource:
url: jdbc:h2:mem:course_db;DB_CLOSE_DELAY=-1;MODE=PostgreSQL;LOCK_TIMEOUT=3000
driver-class-name: org.h2.Driver
username: sa
password:
flyway:
locations: classpath:db/migration/h2
jpa:
hibernate:
ddl-auto: create-drop
show-sql: true
properties:
hibernate:
+7 -2
View File
@@ -1,11 +1,16 @@
server:
address: ${SERVER_ADDRESS:0.0.0.0}
spring:
datasource:
url: jdbc:postgresql://${DB_HOST}:${DB_PORT}/${DB_NAME}
username: ${DB_USERNAME}
password: ${DB_PASSWORD}
hikari:
connection-init-sql: SET lock_timeout TO '3s'
flyway:
locations: classpath:db/migration/postgresql
jpa:
hibernate:
ddl-auto: validate
show-sql: false
h2:
console:
+22 -3
View File
@@ -1,16 +1,25 @@
server:
address: ${SERVER_ADDRESS:127.0.0.1}
port: ${SERVER_PORT:8080}
shutdown: graceful
spring:
application:
name: ${APP_NAME:course-registration}
profiles:
default: local
jackson:
time-zone: UTC
jpa:
open-in-view: false
hibernate:
ddl-auto: validate
lifecycle:
timeout-per-shutdown-phase: 30s
datasource:
url: ${DB_URL}
hikari:
connection-timeout: 2000
validation-timeout: 1000
maximum-pool-size: ${DB_POOL_MAX_SIZE:20}
minimum-idle: ${DB_POOL_MIN_IDLE:2}
springdoc:
api-docs:
@@ -28,3 +37,13 @@ management:
health:
probes:
enabled: true
group:
liveness:
include: livenessState
readiness:
include: readinessState,db
app:
idempotency:
ttl-seconds: 86400
cleanup-delay-ms: 3600000
@@ -0,0 +1,131 @@
CREATE TABLE semesters (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
name VARCHAR(255) NOT NULL,
start_date DATE NOT NULL,
end_date DATE NOT NULL,
registration_start_at TIMESTAMP WITH TIME ZONE NOT NULL,
registration_end_at TIMESTAMP WITH TIME ZONE NOT NULL,
max_credits INTEGER NOT NULL,
created_at TIMESTAMP WITH TIME ZONE NOT NULL,
expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
CONSTRAINT uk_semester_name UNIQUE (name),
CONSTRAINT ck_semester_dates CHECK (end_date >= start_date),
CONSTRAINT ck_semester_registration_window CHECK (registration_start_at < registration_end_at),
CONSTRAINT ck_semester_max_credits CHECK (max_credits >= 1)
);
CREATE TABLE professors (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
name VARCHAR(255) NOT NULL,
created_at TIMESTAMP WITH TIME ZONE NOT NULL,
expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
updated_at TIMESTAMP WITH TIME ZONE NOT NULL
);
CREATE TABLE subjects (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
name VARCHAR(255) NOT NULL,
code VARCHAR(255) NOT NULL,
description VARCHAR(1000) NOT NULL,
credit INTEGER NOT NULL,
created_at TIMESTAMP WITH TIME ZONE NOT NULL,
expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
CONSTRAINT uk_subject_code UNIQUE (code),
CONSTRAINT ck_subject_credit CHECK (credit >= 1)
);
CREATE TABLE users (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
name VARCHAR(255) NOT NULL,
grade BIGINT NOT NULL,
role VARCHAR(64) NOT NULL,
created_at TIMESTAMP WITH TIME ZONE NOT NULL,
expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
CONSTRAINT ck_user_grade CHECK (grade >= 1)
);
CREATE TABLE lessons (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
name VARCHAR(255) NOT NULL,
subject_id VARCHAR(36) NOT NULL,
professor_id VARCHAR(36) NOT NULL,
semester_id VARCHAR(36) NOT NULL,
capacity INTEGER NOT NULL,
min_grade BIGINT,
allowed_role VARCHAR(64),
created_at TIMESTAMP WITH TIME ZONE NOT NULL,
expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
CONSTRAINT fk_lesson_subject FOREIGN KEY (subject_id) REFERENCES subjects(id),
CONSTRAINT fk_lesson_professor FOREIGN KEY (professor_id) REFERENCES professors(id),
CONSTRAINT fk_lesson_semester FOREIGN KEY (semester_id) REFERENCES semesters(id),
CONSTRAINT ck_lesson_capacity CHECK (capacity >= 1),
CONSTRAINT ck_lesson_min_grade CHECK (min_grade IS NULL OR min_grade >= 1)
);
CREATE TABLE lesson_schedules (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
lesson_id VARCHAR(36) NOT NULL,
day_of_week INTEGER NOT NULL,
start_time TIME NOT NULL,
end_time TIME NOT NULL,
created_at TIMESTAMP WITH TIME ZONE NOT NULL,
expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
CONSTRAINT fk_schedule_lesson FOREIGN KEY (lesson_id) REFERENCES lessons(id),
CONSTRAINT ck_schedule_day CHECK (day_of_week BETWEEN 1 AND 7),
CONSTRAINT ck_schedule_time CHECK (start_time < end_time),
CONSTRAINT uk_lesson_schedule UNIQUE (lesson_id, day_of_week, start_time, end_time)
);
CREATE TABLE user_lessons (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
user_id VARCHAR(36) NOT NULL,
lesson_id VARCHAR(36) NOT NULL,
created_at TIMESTAMP WITH TIME ZONE NOT NULL,
expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
canceled_at TIMESTAMP WITH TIME ZONE,
active_lesson_id VARCHAR(36) GENERATED ALWAYS AS (CASE WHEN canceled_at IS NULL THEN lesson_id END),
CONSTRAINT fk_user_lesson_user FOREIGN KEY (user_id) REFERENCES users(id),
CONSTRAINT fk_user_lesson_lesson FOREIGN KEY (lesson_id) REFERENCES lessons(id),
CONSTRAINT uk_user_active_lesson UNIQUE (user_id, active_lesson_id)
);
CREATE INDEX idx_user_lessons_user_active ON user_lessons(user_id, canceled_at);
CREATE INDEX idx_user_lessons_lesson_active ON user_lessons(lesson_id, canceled_at);
CREATE INDEX idx_lessons_semester_subject ON lessons(semester_id, subject_id);
CREATE INDEX idx_schedules_lesson ON lesson_schedules(lesson_id);
CREATE TABLE registration_idempotencies (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
user_id VARCHAR(36) NOT NULL,
lesson_id VARCHAR(36) NOT NULL,
registration_id VARCHAR(36) NOT NULL,
idempotency_key VARCHAR(100) NOT NULL,
total_credits INTEGER NOT NULL,
created_at TIMESTAMP WITH TIME ZONE NOT NULL,
expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
CONSTRAINT fk_idempotency_user FOREIGN KEY (user_id) REFERENCES users(id),
CONSTRAINT fk_idempotency_lesson FOREIGN KEY (lesson_id) REFERENCES lessons(id),
CONSTRAINT fk_idempotency_registration FOREIGN KEY (registration_id) REFERENCES user_lessons(id),
CONSTRAINT uk_registration_idempotency UNIQUE (user_id, idempotency_key),
CONSTRAINT uk_idempotency_registration UNIQUE (registration_id)
);
CREATE INDEX idx_idempotency_expires_at ON registration_idempotencies(expires_at);
CREATE TABLE seed_locks (
name VARCHAR(100) PRIMARY KEY
);
INSERT INTO seed_locks(name) VALUES ('demo-dataset');
@@ -0,0 +1,124 @@
CREATE TABLE semesters (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
name VARCHAR(255) NOT NULL,
start_date DATE NOT NULL,
end_date DATE NOT NULL,
registration_start_at TIMESTAMPTZ NOT NULL,
registration_end_at TIMESTAMPTZ NOT NULL,
max_credits INTEGER NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL,
CONSTRAINT uk_semester_name UNIQUE (name),
CONSTRAINT ck_semester_dates CHECK (end_date >= start_date),
CONSTRAINT ck_semester_registration_window CHECK (registration_start_at < registration_end_at),
CONSTRAINT ck_semester_max_credits CHECK (max_credits >= 1)
);
CREATE TABLE professors (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
name VARCHAR(255) NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE subjects (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
name VARCHAR(255) NOT NULL,
code VARCHAR(255) NOT NULL,
description VARCHAR(1000) NOT NULL,
credit INTEGER NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL,
CONSTRAINT uk_subject_code UNIQUE (code),
CONSTRAINT ck_subject_credit CHECK (credit >= 1)
);
CREATE TABLE users (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
name VARCHAR(255) NOT NULL,
grade BIGINT NOT NULL,
role VARCHAR(64) NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL,
CONSTRAINT ck_user_grade CHECK (grade >= 1)
);
CREATE TABLE lessons (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
name VARCHAR(255) NOT NULL,
subject_id VARCHAR(36) NOT NULL,
professor_id VARCHAR(36) NOT NULL,
semester_id VARCHAR(36) NOT NULL,
capacity INTEGER NOT NULL,
min_grade BIGINT,
allowed_role VARCHAR(64),
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL,
CONSTRAINT fk_lesson_subject FOREIGN KEY (subject_id) REFERENCES subjects(id),
CONSTRAINT fk_lesson_professor FOREIGN KEY (professor_id) REFERENCES professors(id),
CONSTRAINT fk_lesson_semester FOREIGN KEY (semester_id) REFERENCES semesters(id),
CONSTRAINT ck_lesson_capacity CHECK (capacity >= 1),
CONSTRAINT ck_lesson_min_grade CHECK (min_grade IS NULL OR min_grade >= 1)
);
CREATE TABLE lesson_schedules (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
lesson_id VARCHAR(36) NOT NULL,
day_of_week INTEGER NOT NULL,
start_time TIME WITHOUT TIME ZONE NOT NULL,
end_time TIME WITHOUT TIME ZONE NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL,
CONSTRAINT fk_schedule_lesson FOREIGN KEY (lesson_id) REFERENCES lessons(id),
CONSTRAINT ck_schedule_day CHECK (day_of_week BETWEEN 1 AND 7),
CONSTRAINT ck_schedule_time CHECK (start_time < end_time),
CONSTRAINT uk_lesson_schedule UNIQUE (lesson_id, day_of_week, start_time, end_time)
);
CREATE TABLE user_lessons (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
user_id VARCHAR(36) NOT NULL,
lesson_id VARCHAR(36) NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
canceled_at TIMESTAMPTZ,
active_lesson_id VARCHAR(36) GENERATED ALWAYS AS (CASE WHEN canceled_at IS NULL THEN lesson_id END) STORED,
CONSTRAINT fk_user_lesson_user FOREIGN KEY (user_id) REFERENCES users(id),
CONSTRAINT fk_user_lesson_lesson FOREIGN KEY (lesson_id) REFERENCES lessons(id),
CONSTRAINT uk_user_active_lesson UNIQUE (user_id, active_lesson_id)
);
CREATE INDEX idx_user_lessons_user_active ON user_lessons(user_id, canceled_at);
CREATE INDEX idx_user_lessons_lesson_active ON user_lessons(lesson_id, canceled_at);
CREATE INDEX idx_lessons_semester_subject ON lessons(semester_id, subject_id);
CREATE INDEX idx_schedules_lesson ON lesson_schedules(lesson_id);
CREATE TABLE registration_idempotencies (
id VARCHAR(36) PRIMARY KEY,
version BIGINT NOT NULL DEFAULT 0,
user_id VARCHAR(36) NOT NULL,
lesson_id VARCHAR(36) NOT NULL,
registration_id VARCHAR(36) NOT NULL,
idempotency_key VARCHAR(100) NOT NULL,
total_credits INTEGER NOT NULL,
created_at TIMESTAMP WITH TIME ZONE NOT NULL,
expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
CONSTRAINT fk_idempotency_user FOREIGN KEY (user_id) REFERENCES users(id),
CONSTRAINT fk_idempotency_lesson FOREIGN KEY (lesson_id) REFERENCES lessons(id),
CONSTRAINT fk_idempotency_registration FOREIGN KEY (registration_id) REFERENCES user_lessons(id),
CONSTRAINT uk_registration_idempotency UNIQUE (user_id, idempotency_key),
CONSTRAINT uk_idempotency_registration UNIQUE (registration_id)
);
CREATE INDEX idx_idempotency_expires_at ON registration_idempotencies(expires_at);
CREATE TABLE seed_locks (
name VARCHAR(100) PRIMARY KEY
);
INSERT INTO seed_locks(name) VALUES ('demo-dataset');
+8
View File
@@ -0,0 +1,8 @@
id name subjectId professorId semesterId capacity minGrade allowedRole
40000000-0000-0000-0000-000000000001 자료구조 01분반 20000000-0000-0000-0000-000000000002 10000000-0000-0000-0000-000000000001 00000000-0000-0000-0000-000000000001 30
40000000-0000-0000-0000-000000000002 자료구조 02분반 20000000-0000-0000-0000-000000000002 10000000-0000-0000-0000-000000000002 00000000-0000-0000-0000-000000000001 30
40000000-0000-0000-0000-000000000003 운영체제 20000000-0000-0000-0000-000000000005 10000000-0000-0000-0000-000000000002 00000000-0000-0000-0000-000000000001 30
40000000-0000-0000-0000-000000000004 데이터베이스 소수정예 20000000-0000-0000-0000-000000000003 10000000-0000-0000-0000-000000000003 00000000-0000-0000-0000-000000000001 1
40000000-0000-0000-0000-000000000005 고급 네트워크 20000000-0000-0000-0000-000000000004 10000000-0000-0000-0000-000000000003 00000000-0000-0000-0000-000000000001 30 3
40000000-0000-0000-0000-000000000006 대학원 세미나 20000000-0000-0000-0000-000000000006 10000000-0000-0000-0000-000000000001 00000000-0000-0000-0000-000000000001 20 POSTGRADUATE
40000000-0000-0000-0000-000000000007 자바 프로그래밍 20000000-0000-0000-0000-000000000001 10000000-0000-0000-0000-000000000001 00000000-0000-0000-0000-000000000001 30
1 id name subjectId professorId semesterId capacity minGrade allowedRole
2 40000000-0000-0000-0000-000000000001 자료구조 01분반 20000000-0000-0000-0000-000000000002 10000000-0000-0000-0000-000000000001 00000000-0000-0000-0000-000000000001 30
3 40000000-0000-0000-0000-000000000002 자료구조 02분반 20000000-0000-0000-0000-000000000002 10000000-0000-0000-0000-000000000002 00000000-0000-0000-0000-000000000001 30
4 40000000-0000-0000-0000-000000000003 운영체제 20000000-0000-0000-0000-000000000005 10000000-0000-0000-0000-000000000002 00000000-0000-0000-0000-000000000001 30
5 40000000-0000-0000-0000-000000000004 데이터베이스 소수정예 20000000-0000-0000-0000-000000000003 10000000-0000-0000-0000-000000000003 00000000-0000-0000-0000-000000000001 1
6 40000000-0000-0000-0000-000000000005 고급 네트워크 20000000-0000-0000-0000-000000000004 10000000-0000-0000-0000-000000000003 00000000-0000-0000-0000-000000000001 30 3
7 40000000-0000-0000-0000-000000000006 대학원 세미나 20000000-0000-0000-0000-000000000006 10000000-0000-0000-0000-000000000001 00000000-0000-0000-0000-000000000001 20 POSTGRADUATE
8 40000000-0000-0000-0000-000000000007 자바 프로그래밍 20000000-0000-0000-0000-000000000001 10000000-0000-0000-0000-000000000001 00000000-0000-0000-0000-000000000001 30
@@ -0,0 +1,4 @@
id name
10000000-0000-0000-0000-000000000001 김영한
10000000-0000-0000-0000-000000000002 최태영
10000000-0000-0000-0000-000000000003 조재한
1 id name
2 10000000-0000-0000-0000-000000000001 김영한
3 10000000-0000-0000-0000-000000000002 최태영
4 10000000-0000-0000-0000-000000000003 조재한
@@ -0,0 +1,8 @@
id lessonId dayOfWeek startTime endTime
50000000-0000-0000-0000-000000000001 40000000-0000-0000-0000-000000000001 MONDAY 09:00 11:00
50000000-0000-0000-0000-000000000002 40000000-0000-0000-0000-000000000002 TUESDAY 09:00 11:00
50000000-0000-0000-0000-000000000003 40000000-0000-0000-0000-000000000003 MONDAY 10:00 12:00
50000000-0000-0000-0000-000000000004 40000000-0000-0000-0000-000000000004 WEDNESDAY 09:00 11:00
50000000-0000-0000-0000-000000000005 40000000-0000-0000-0000-000000000005 THURSDAY 09:00 11:00
50000000-0000-0000-0000-000000000006 40000000-0000-0000-0000-000000000006 FRIDAY 09:00 11:00
50000000-0000-0000-0000-000000000007 40000000-0000-0000-0000-000000000007 MONDAY 11:00 13:00
1 id lessonId dayOfWeek startTime endTime
2 50000000-0000-0000-0000-000000000001 40000000-0000-0000-0000-000000000001 MONDAY 09:00 11:00
3 50000000-0000-0000-0000-000000000002 40000000-0000-0000-0000-000000000002 TUESDAY 09:00 11:00
4 50000000-0000-0000-0000-000000000003 40000000-0000-0000-0000-000000000003 MONDAY 10:00 12:00
5 50000000-0000-0000-0000-000000000004 40000000-0000-0000-0000-000000000004 WEDNESDAY 09:00 11:00
6 50000000-0000-0000-0000-000000000005 40000000-0000-0000-0000-000000000005 THURSDAY 09:00 11:00
7 50000000-0000-0000-0000-000000000006 40000000-0000-0000-0000-000000000006 FRIDAY 09:00 11:00
8 50000000-0000-0000-0000-000000000007 40000000-0000-0000-0000-000000000007 MONDAY 11:00 13:00
@@ -0,0 +1,2 @@
id name startDate endDate registrationStartAt registrationEndAt maxCredits
00000000-0000-0000-0000-000000000001 current 2000-01-01 2099-12-31 2000-01-01T00:00:00Z 2099-12-31T23:59:59Z 18
1 id name startDate endDate registrationStartAt registrationEndAt maxCredits
2 00000000-0000-0000-0000-000000000001 current 2000-01-01 2099-12-31 2000-01-01T00:00:00Z 2099-12-31T23:59:59Z 18
@@ -0,0 +1,7 @@
id name code description credit
20000000-0000-0000-0000-000000000001 자바 프로그래밍 CS201 자바 프로그래밍 기초 3
20000000-0000-0000-0000-000000000002 자료구조 CS202 자료구조 및 알고리즘 3
20000000-0000-0000-0000-000000000003 데이터베이스 CS203 데이터베이스 시스템 3
20000000-0000-0000-0000-000000000004 컴퓨터 네트워크 CS204 네트워크 기초 3
20000000-0000-0000-0000-000000000005 운영체제 CS301 운영체제 핵심 3
20000000-0000-0000-0000-000000000006 대학원 세미나 CS401 대학원 전용 세미나 3
1 id name code description credit
2 20000000-0000-0000-0000-000000000001 자바 프로그래밍 CS201 자바 프로그래밍 기초 3
3 20000000-0000-0000-0000-000000000002 자료구조 CS202 자료구조 및 알고리즘 3
4 20000000-0000-0000-0000-000000000003 데이터베이스 CS203 데이터베이스 시스템 3
5 20000000-0000-0000-0000-000000000004 컴퓨터 네트워크 CS204 네트워크 기초 3
6 20000000-0000-0000-0000-000000000005 운영체제 CS301 운영체제 핵심 3
7 20000000-0000-0000-0000-000000000006 대학원 세미나 CS401 대학원 전용 세미나 3
+4
View File
@@ -0,0 +1,4 @@
id name grade role
30000000-0000-0000-0000-000000000001 학생1 1 STUDENT
30000000-0000-0000-0000-000000000002 학생2 2 STUDENT
30000000-0000-0000-0000-000000000003 대학원생 3 POSTGRADUATE
1 id name grade role
2 30000000-0000-0000-0000-000000000001 학생1 1 STUDENT
3 30000000-0000-0000-0000-000000000002 학생2 2 STUDENT
4 30000000-0000-0000-0000-000000000003 대학원생 3 POSTGRADUATE
@@ -2,8 +2,10 @@ package com.study.course_registration;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
@SpringBootTest
@ActiveProfiles("test")
class CourseRegistrationApplicationTests {
@Test
@@ -0,0 +1,73 @@
package com.study.course_registration.architecture;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noFields;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import com.tngtech.archunit.core.domain.JavaClasses;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import java.nio.file.Path;
import jakarta.persistence.ManyToMany;
import jakarta.persistence.OneToMany;
import jakarta.persistence.OneToOne;
class ArchitectureTest {
@Test
@DisplayName("수강신청 mutation → RegistrationLockManager 의존")
void registrationMutationUsesLockBoundary() {
JavaClasses classes = new ClassFileImporter().importPath(Path.of("build/classes/java/main"));
classes()
.that().haveSimpleName("CourseRegistrationService")
.should().dependOnClassesThat().haveSimpleName("RegistrationLockManager")
.check(classes);
noClasses()
.that().haveSimpleName("CourseRegistrationService")
.should().dependOnClassesThat().haveSimpleName("LessonRepository")
.check(classes);
}
@Test
@DisplayName("새 service → registration write repository 우회 금지")
void registrationWriteRepositoriesStayInsideApprovedServices() {
JavaClasses classes = new ClassFileImporter().importPath(Path.of("build/classes/java/main"));
noClasses()
.that().resideInAPackage("..service..")
.and().doNotHaveSimpleName("CourseRegistrationService")
.and().doNotHaveSimpleName("LessonQueryService")
.should().dependOnClassesThat().haveSimpleName("UserLessonRepository")
.check(classes);
noClasses()
.that().resideInAPackage("..service..")
.and().doNotHaveSimpleName("CourseRegistrationService")
.should().dependOnClassesThat().haveSimpleName("RegistrationIdempotencyRepository")
.check(classes);
}
@Test
@DisplayName("엔티티 연관관계 → ManyToOne만 허용")
void entityAssociationsUseManyToOneOnly() {
JavaClasses classes = new ClassFileImporter().importPath(Path.of("build/classes/java/main"));
noFields()
.that().areDeclaredInClassesThat().resideInAPackage("..entity..")
.should().beAnnotatedWith(OneToOne.class)
.check(classes);
noFields()
.that().areDeclaredInClassesThat().resideInAPackage("..entity..")
.should().beAnnotatedWith(OneToMany.class)
.check(classes);
noFields()
.that().areDeclaredInClassesThat().resideInAPackage("..entity..")
.should().beAnnotatedWith(ManyToMany.class)
.check(classes);
}
}
@@ -0,0 +1,65 @@
package com.study.course_registration.architecture;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
class SourceStyleTest {
private static final Pattern LOCAL_VAR = Pattern.compile("\\bvar\\s+[A-Za-z_$][A-Za-z0-9_$]*");
private static final Pattern FQCN = Pattern.compile(
"(?:com\\.study\\.course_registration(?:\\.[a-z_][a-z0-9_]*)+|java\\.(?:util|time)(?:\\.[a-z_][a-z0-9_]*)*)\\.[A-Z][A-Za-z0-9_$]*");
@Test
@DisplayName("소스 스타일 → var·본문 FQCN·wildcard import 금지")
void sourceStyle() throws IOException {
List<String> violations = new ArrayList<>();
for (Path sourceRoot : List.of(Path.of("src/main/java"), Path.of("src/test/java"))) {
try (Stream<Path> files = Files.walk(sourceRoot)) {
files.filter(path -> path.toString().endsWith(".java"))
.forEach(path -> inspect(path, violations));
}
}
assertThat(violations)
.as("명시적 타입/import 규칙 위반")
.isEmpty();
}
private static void inspect(Path path, List<String> violations) {
try {
List<String> lines = Files.readAllLines(path);
for (int index = 0; index < lines.size(); index++) {
String line = lines.get(index);
String trimmed = line.trim();
if (trimmed.startsWith("import ") && trimmed.contains(".*;")) {
violations.add(location(path, index, "wildcard import"));
}
if (LOCAL_VAR.matcher(line).find()) {
violations.add(location(path, index, "var"));
}
if (!trimmed.startsWith("package ")
&& !trimmed.startsWith("import ")
&& FQCN.matcher(line).find()) {
violations.add(location(path, index, "본문 FQCN"));
}
}
} catch (IOException exception) {
throw new IllegalStateException("소스 스타일 검사 실패: " + path, exception);
}
}
private static String location(Path path, int zeroBasedLine, String reason) {
return path + ":" + (zeroBasedLine + 1) + " " + reason;
}
}
@@ -0,0 +1,44 @@
package com.study.course_registration.config;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.DayOfWeek;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import com.study.course_registration.enums.UserRole;
class EnumConverterTest {
@Test
@DisplayName("DayOfWeek → ISO 요일 번호")
void dayOfWeek() {
DayOfWeekConverter converter = new DayOfWeekConverter();
assertThat(converter.convertToDatabaseColumn(DayOfWeek.MONDAY)).isEqualTo(1);
assertThat(converter.convertToEntityAttribute(7)).isEqualTo(DayOfWeek.SUNDAY);
}
@Test
@DisplayName("UserRole → 이름 문자열")
void userRole() {
UserRoleConverter converter = new UserRoleConverter();
assertThat(converter.convertToDatabaseColumn(UserRole.POSTGRADUATE)).isEqualTo("POSTGRADUATE");
assertThat(converter.convertToEntityAttribute("STUDENT")).isEqualTo(UserRole.STUDENT);
}
@Test
@DisplayName("enum null → DB null")
void nullValues() {
DayOfWeekConverter day = new DayOfWeekConverter();
UserRoleConverter role = new UserRoleConverter();
assertThat(day.convertToDatabaseColumn(null)).isNull();
assertThat(day.convertToEntityAttribute(null)).isNull();
assertThat(role.convertToDatabaseColumn(null)).isNull();
assertThat(role.convertToEntityAttribute(null)).isNull();
}
}
@@ -0,0 +1,58 @@
package com.study.course_registration.config;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
class RuntimeProfileConfigTest {
@Test
@DisplayName("환경 profile 없음 → 기동 거부")
void missingProfile() {
assertThatThrownBy(() -> RuntimeProfileConfig.requireValidProfiles(new String[0]))
.isInstanceOf(IllegalStateException.class);
}
@Test
@DisplayName("오타 profile만 활성화 → 기동 거부")
void typoProfile() {
assertThatThrownBy(() -> RuntimeProfileConfig.requireValidProfiles(new String[]{"loacl"}))
.isInstanceOf(IllegalStateException.class);
}
@Test
@DisplayName("dev profile 하나 → 기동 허용")
void devProfile() {
assertThatCode(() -> RuntimeProfileConfig.requireValidProfiles(new String[]{"dev"}))
.doesNotThrowAnyException();
}
@Test
@DisplayName("dev + feature profile → 기동 허용")
void featureProfile() {
assertThatCode(() -> RuntimeProfileConfig.requireValidProfiles(new String[]{"dev", "metrics"}))
.doesNotThrowAnyException();
}
@Test
@DisplayName("local + prod → 기동 거부")
void multipleEnvironmentProfiles() {
assertThatThrownBy(() -> RuntimeProfileConfig.requireValidProfiles(new String[]{"local", "prod"}))
.isInstanceOf(IllegalStateException.class);
}
@Test
@DisplayName("test profile 하나 → 테스트 기동 허용")
void testProfile() {
assertThatCode(() -> RuntimeProfileConfig.requireValidProfiles(new String[]{"test"}))
.doesNotThrowAnyException();
}
@Test
@DisplayName("test + prod → 기동 거부")
void testAndEnvironmentProfile() {
assertThatThrownBy(() -> RuntimeProfileConfig.requireValidProfiles(new String[]{"test", "prod"}))
.isInstanceOf(IllegalStateException.class);
}
}
@@ -1,204 +1,263 @@
package com.study.course_registration.controller;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.catchThrowableOfType;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.Map;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.web.servlet.MockMvc;
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.entity.User;
import com.study.course_registration.enums.RegistrationErrorCode;
import com.study.course_registration.enums.UserRole;
import com.study.course_registration.repository.LessonRepository;
import com.study.course_registration.repository.LessonScheduleRepository;
import com.study.course_registration.repository.ProfessorRepository;
import com.study.course_registration.repository.SemesterRepository;
import com.study.course_registration.repository.SubjectRepository;
import com.study.course_registration.repository.UserLessonRepository;
import com.study.course_registration.repository.UserRepository;
import com.study.course_registration.support.CourseIntegrationTest;
import com.study.course_registration.support.Rejections;
import com.study.course_registration.support.Scenario;
import com.study.course_registration.support.fixture.DatabaseFixture;
import com.study.course_registration.support.fixture.DatabaseFixture.RegistrationDataset;
import com.study.course_registration.support.fixture.DomainFixtures;
import com.study.course_registration.support.http.ApiError;
import com.study.course_registration.support.http.JsonApi;
import com.study.course_registration.support.http.JsonBody;
/**
* HTTP 계층. 서비스가 올바른 예외를 던지는 것과, 그게 올바른 상태코드·바디로 나가는 것은 다른 문제다.
* 여기서만 확인할 수 있는 것이 후자다.
*
* <p>표현법은 단위·통합 계층과 같다. {@code Scenario.given(...).when(...).then(...)}.
* HTTP 응답을 {@link ApiError}로 번역하는 일은 {@link JsonApi}가 한다.
*/
@SpringBootTest
@CourseIntegrationTest
@AutoConfigureMockMvc
@ActiveProfiles("test")
@DisplayName("수강신청 API — 에러 코드가 선언된 상태코드로 나가는가")
@DisplayName("수강신청 API")
class CourseRegistrationApiTest {
/**
* HTTP 계층의 거부 판정. 코드를 꺼내면서 <em>그 코드가 선언한 상태코드로 나갔는지</em>도 함께 본다.
* 매핑표는 이미 {@link RegistrationErrorCode}에 있으므로, 테스트는 코드만 적으면 상태코드까지 검증된다.
*/
private static final Rejections<ApiError, RegistrationErrorCode> API =
Rejections.of(ApiError.class, CourseRegistrationApiTest::errorCodeOf);
@Autowired MockMvc mockMvc;
@Autowired UserLessonRepository userLessonRepository;
@Autowired LessonScheduleRepository lessonScheduleRepository;
@Autowired LessonRepository lessonRepository;
@Autowired SubjectRepository subjectRepository;
@Autowired ProfessorRepository professorRepository;
@Autowired SemesterRepository semesterRepository;
@Autowired UserRepository userRepository;
@Autowired DatabaseFixture fixture;
private JsonApi api;
private User student;
private Lesson lesson;
private Subject subject;
private RegistrationDataset data;
@BeforeEach
void setUp() {
userLessonRepository.deleteAll();
lessonScheduleRepository.deleteAll();
lessonRepository.deleteAll();
subjectRepository.deleteAll();
professorRepository.deleteAll();
semesterRepository.deleteAll();
userRepository.deleteAll();
Instant now = Instant.now();
Semester semester = semesterRepository.save(new Semester("semester", "2026-1",
LocalDate.now().minusDays(1), LocalDate.now().plusDays(100),
now.minusSeconds(3600), now.plusSeconds(3600), 18));
Professor professor = professorRepository.save(new Professor("professor", "교수"));
subject = subjectRepository.save(new Subject("subject-a", "과목A", "A101", "A", 3));
student = userRepository.save(new User("user", "학생", 2L, UserRole.STUDENT));
lesson = lessonRepository.save(new Lesson("lesson-a", "강의A", subject, professor, semester, 30, null, null));
lessonScheduleRepository.save(new LessonSchedule("schedule-a", lesson,
DayOfWeek.MONDAY, LocalTime.of(9, 0), LocalTime.of(11, 0)));
data = fixture.registrationDataset();
api = new JsonApi(mockMvc);
}
@Test
@DisplayName("신청에 성공하면 201과 신청 정보를 돌려준다")
void registerReturnsCreated() {
JsonBody body = Scenario.given(api)
.when(a -> a.post(path(student.getId()), json(lesson.getId())))
.thenAccepted();
assertThat(body.status())
.as("신청 성공은 201이다")
.isEqualTo(201);
// 응답 스키마 전체를 고정한다. 값 몇 개만 보면 필드 이름이 바뀌어도 통과한다.
assertThat(body.fieldNames())
.as("응답 필드 이름은 클라이언트와의 계약이다")
.containsExactlyInAnyOrder(
"registrationId", "userId", "lessonId", "lessonName",
"subjectCode", "credit", "registeredAt", "totalCredits");
assertThat(body.<String>at("$.userId")).isEqualTo(student.getId());
assertThat(body.<String>at("$.lessonId")).isEqualTo(lesson.getId());
assertThat(body.<String>at("$.lessonName")).isEqualTo(lesson.getName());
assertThat(body.<String>at("$.subjectCode")).isEqualTo(subject.getCode());
assertThat(body.<Integer>at("$.credit")).isEqualTo(3);
assertThat(body.<Integer>at("$.totalCredits")).isEqualTo(3);
assertThat(body.<String>at("$.registrationId")).isNotBlank();
assertThat(body.<String>at("$.registeredAt")).isNotBlank();
@DisplayName("POST 신청 성공 → 201")
void register201() {
Scenario.given(data)
.when(current -> api.post(
path(current.student().getId()),
json(current.lesson().getId())))
.then(body -> {
assertThat(body.status()).isEqualTo(201);
assertThat(body.fieldNames()).containsExactlyInAnyOrder(
"registrationId",
"userId",
"lessonId",
"lessonName",
"subjectCode",
"credit",
"registeredAt",
"totalCredits");
assertThat(body.<String>at("$.userId")).isEqualTo(data.student().getId());
assertThat(body.<String>at("$.lessonId")).isEqualTo(data.lesson().getId());
assertThat(body.<String>at("$.lessonName")).isEqualTo(data.lesson().getName());
assertThat(body.<String>at("$.subjectCode")).isEqualTo(data.subject().getCode());
assertThat(body.<Integer>at("$.credit")).isEqualTo(3);
assertThat(body.<Integer>at("$.totalCredits")).isEqualTo(3);
assertThat(body.<String>at("$.registrationId")).isNotBlank();
assertThat(body.<String>at("$.registeredAt")).isEqualTo("2026-09-21T03:00:00Z");
});
}
@Test
@DisplayName("취소에 성공하면 204와 빈 본문을 돌려준다")
void cancelReturnsNoContent() {
JsonBody created = api.post(path(student.getId()), json(lesson.getId()));
String registrationId = created.at("$.registrationId");
@DisplayName("GET 신청 목록 → 200 + 응답 계약")
void registrations200() {
api.post(path(data.student().getId()), json(data.lesson().getId()));
JsonBody body = Scenario.given(api)
.when(a -> a.delete(path(student.getId()) + "/" + registrationId))
.thenAccepted();
assertThat(body.status())
.as("취소 성공은 204다")
.isEqualTo(204);
assertThat(body.raw())
.as("204에는 본문이 없다")
.isEmpty();
Scenario.given(data)
.when(current -> api.get(
path(current.student().getId())
+ "?semesterId="
+ current.semester().getId()))
.then(body -> {
assertThat(body.status()).isEqualTo(200);
assertThat(body.fieldNames()).containsExactlyInAnyOrder(
"userId",
"semesterId",
"semesterName",
"totalCredits",
"maxCredits",
"registrations");
assertThat(body.<String>at("$.userId")).isEqualTo(data.student().getId());
assertThat(body.<String>at("$.semesterId")).isEqualTo(data.semester().getId());
assertThat(body.<Integer>at("$.totalCredits")).isEqualTo(3);
Map<String, Object> item = body.at("$.registrations[0]");
assertThat(item.keySet()).containsExactlyInAnyOrder(
"registrationId",
"lessonId",
"lessonName",
"subjectCode",
"subjectName",
"credit",
"professorName",
"schedules",
"registeredAt");
});
}
@Test
@DisplayName("없는 사용자로 신청하면 USER_NOT_FOUND — 404로 나간다")
void unknownUserIsNotFound() {
Scenario.given(api)
.when(a -> a.post(path("no-such-user"), json(lesson.getId())))
@DisplayName("같은 Idempotency-Key 재시도 → 동일 201 응답")
void idempotentPost() {
JsonBody first = api.post(
path(data.student().getId()),
json(data.lesson().getId()),
"request-1");
Scenario.given(first)
.when(previous -> api.post(
path(data.student().getId()),
json(data.lesson().getId()),
"request-1"))
.then(second -> {
assertThat(first.status()).isEqualTo(201);
assertThat(second.status()).isEqualTo(201);
assertThat(second.<String>at("$.registrationId"))
.isEqualTo(first.<String>at("$.registrationId"));
assertThat(second.<String>at("$.registeredAt"))
.isEqualTo(first.<String>at("$.registeredAt"));
});
}
@Test
@DisplayName("같은 Idempotency-Key 다른 강의 → 409")
void reusedIdempotencyKey409() {
api.post(path(data.student().getId()), json(data.lesson().getId()), "request-2");
Subject subject = fixture.subject(DomainFixtures.subject("OTHER"));
Lesson other = fixture.lesson(DomainFixtures.lesson(
subject,
data.professor(),
data.semester()));
fixture.schedule(DomainFixtures.schedule(other, DayOfWeek.TUESDAY, 13, 15));
Scenario.given(other)
.when(lesson -> api.post(
path(data.student().getId()),
json(lesson.getId()),
"request-2"))
.thenRejectedWith(API, RegistrationErrorCode.IDEMPOTENCY_KEY_REUSED);
}
@Test
@DisplayName("DELETE 취소 성공 → 204")
void cancel204() {
String id = api.post(
path(data.student().getId()),
json(data.lesson().getId()))
.at("$.registrationId");
Scenario.given(id)
.when(registrationId -> api.delete(
path(data.student().getId()) + "/" + registrationId))
.then(body -> {
assertThat(body.status()).isEqualTo(204);
assertThat(body.raw()).isEmpty();
});
}
@Test
@DisplayName("DELETE 재호출 → 204")
void repeatedCancel204() {
String id = api.post(
path(data.student().getId()),
json(data.lesson().getId()))
.at("$.registrationId");
api.delete(path(data.student().getId()) + "/" + id);
Scenario.given(id)
.when(registrationId -> api.delete(
path(data.student().getId()) + "/" + registrationId))
.then(body -> assertThat(body.status()).isEqualTo(204));
}
@Test
@DisplayName("없는 사용자 → 404 USER_NOT_FOUND")
void user404() {
Scenario.given("missing")
.when(userId -> api.post(path(userId), json(data.lesson().getId())))
.thenRejectedWith(API, RegistrationErrorCode.USER_NOT_FOUND);
}
@Test
@DisplayName("없는 강의로 신청하면 LESSON_NOT_FOUND — 404로 나간다")
void unknownLessonIsNotFound() {
Scenario.given(api)
.when(a -> a.post(path(student.getId()), json("no-such-lesson")))
@DisplayName("없는 강의 → 404 LESSON_NOT_FOUND")
void lesson404() {
Scenario.given("missing")
.when(lessonId -> api.post(path(data.student().getId()), json(lessonId)))
.thenRejectedWith(API, RegistrationErrorCode.LESSON_NOT_FOUND);
}
@Test
@DisplayName("같은 강의를 두 번 신청하면 ALREADY_REGISTERED — 409로 나간다")
void duplicateRegistrationIsConflict() {
api.post(path(student.getId()), json(lesson.getId()));
@DisplayName("중복 신청 → 409 ALREADY_REGISTERED")
void duplicate409() {
api.post(path(data.student().getId()), json(data.lesson().getId()));
Scenario.given(api)
.when(a -> a.post(path(student.getId()), json(lesson.getId())))
Scenario.given(data)
.when(current -> api.post(
path(current.student().getId()),
json(current.lesson().getId())))
.thenRejectedWith(API, RegistrationErrorCode.ALREADY_REGISTERED);
}
@Test
@DisplayName("lessonId가 비면 VALIDATION_ERROR — 400으로 나간다")
void blankLessonIdIsBadRequest() {
@DisplayName("빈 lessonId → 400 VALIDATION_ERROR")
void blankLesson400() {
Scenario.given(api)
.when(a -> a.post(path(student.getId()), json("")))
.when(client -> client.post(path(data.student().getId()), json("")))
.thenRejectedWith(API, RegistrationErrorCode.VALIDATION_ERROR);
}
@Test
@DisplayName("본문이 JSON이 아니면 VALIDATION_ERROR — 400으로 나간다")
void malformedBodyIsBadRequest() {
@DisplayName("잘못된 JSON → 400 VALIDATION_ERROR")
void malformed400() {
Scenario.given(api)
.when(a -> a.post(path(student.getId()), "{not json"))
.when(client -> client.post(path(data.student().getId()), "{not json"))
.thenRejectedWith(API, RegistrationErrorCode.VALIDATION_ERROR);
}
@Test
@DisplayName("없는 신청 건을 취소하면 REGISTRATION_NOT_FOUND — 404로 나간다 (C1)")
void cancelingUnknownRegistrationIsNotFound() {
@DisplayName("없는 신청 취소 → 404 REGISTRATION_NOT_FOUND")
void registration404() {
Scenario.given(api)
.when(a -> a.delete(path(student.getId()) + "/no-such-registration"))
.when(client -> client.delete(
path(data.student().getId()) + "/missing"))
.thenRejectedWith(API, RegistrationErrorCode.REGISTRATION_NOT_FOUND);
}
@Test
@DisplayName("에러 응답 본문은 code·message·timestamp 세 필드를 담는다")
void errorBodyShape() {
ApiError error = org.assertj.core.api.Assertions.catchThrowableOfType(ApiError.class,
() -> api.post(path("no-such-user"), json(lesson.getId())));
@DisplayName("시간표 없는 강의 → 500 공통 에러")
void missingSchedule500() {
Subject subject = fixture.subject(DomainFixtures.subject("BROKEN"));
Lesson broken = fixture.lesson(DomainFixtures.lesson(
subject,
data.professor(),
data.semester()));
assertThat(error.code()).isEqualTo("USER_NOT_FOUND");
assertThat(error.detail()).isNotBlank();
assertThat(error.status()).isEqualTo(404);
ApiError error = catchThrowableOfType(
ApiError.class,
() -> api.post(
path(data.student().getId()),
json(broken.getId())));
assertThat(error.status()).isEqualTo(500);
assertThat(error.code()).isEqualTo("INTERNAL_SERVER_ERROR");
assertThat(error.fieldNames()).containsExactlyInAnyOrder(
"code",
"message",
"timestamp");
}
private static String path(String userId) {
@@ -206,15 +265,12 @@ class CourseRegistrationApiTest {
}
private static String json(String lessonId) {
return "{\"lessonId\": \"" + lessonId + "\"}";
return "{\"lessonId\":\"" + lessonId + "\"}";
}
/** 코드를 꺼내면서 상태코드 매핑까지 확인한다. HTTP 계층에서만 볼 수 있는 값을 놓치지 않기 위해서다. */
private static RegistrationErrorCode errorCodeOf(ApiError error) {
RegistrationErrorCode code = RegistrationErrorCode.valueOf(error.code());
assertThat(error.status())
.as("%s 는 %s 로 나가야 한다", code, code.getStatus())
.isEqualTo(code.getStatus().value());
assertThat(error.status()).isEqualTo(code.getStatus().value());
return code;
}
}
@@ -0,0 +1,108 @@
package com.study.course_registration.controller;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.test.web.servlet.MockMvc;
import com.study.course_registration.enums.RegistrationErrorCode;
import com.study.course_registration.support.CourseIntegrationTest;
import com.study.course_registration.support.Rejections;
import com.study.course_registration.support.Scenario;
import com.study.course_registration.support.fixture.DatabaseFixture;
import com.study.course_registration.support.fixture.DatabaseFixture.RegistrationDataset;
import com.study.course_registration.support.http.ApiError;
import com.study.course_registration.support.http.JsonApi;
import com.study.course_registration.support.http.JsonBody;
@CourseIntegrationTest
@AutoConfigureMockMvc
@DisplayName("강의 API")
class LessonApiTest {
private static final Rejections<ApiError, RegistrationErrorCode> API =
Rejections.of(ApiError.class, LessonApiTest::errorCodeOf);
@Autowired MockMvc mockMvc;
@Autowired DatabaseFixture fixture;
private JsonApi api;
private RegistrationDataset data;
@BeforeEach
void setUp() {
data = fixture.registrationDataset();
api = new JsonApi(mockMvc);
}
@Test
@DisplayName("GET 목록 → 200")
void list200() {
Scenario.given(api)
.when(client -> client.get(
"/api/v1/lessons?semesterId=" + data.semester().getId()))
.then(body -> {
assertThat(body.status()).isEqualTo(200);
assertThat(body.fieldNames()).containsExactlyInAnyOrder(
"page",
"size",
"totalElements",
"lessons");
assertThat(body.<Integer>at("$.page")).isZero();
assertThat(body.<Integer>at("$.size")).isEqualTo(20);
assertThat(body.<Integer>at("$.lessons.length()")).isEqualTo(1);
});
}
@Test
@DisplayName("GET 상세 → 200")
void detail200() {
Scenario.given(data.lesson().getId())
.when(lessonId -> api.get("/api/v1/lessons/" + lessonId))
.then(body -> {
assertThat(body.status()).isEqualTo(200);
assertThat(body.fieldNames()).contains(
"lessonId",
"lessonName",
"subjectCode",
"subjectName",
"subjectDescription",
"credit",
"professorName",
"semesterName",
"capacity",
"enrolledCount",
"minGrade",
"allowedRole",
"registrationStartAt",
"registrationEndAt",
"schedules");
assertThat(body.<String>at("$.lessonId")).isEqualTo(data.lesson().getId());
});
}
@Test
@DisplayName("page 상한 초과 → 400 VALIDATION_ERROR")
void page400() {
Scenario.given(api)
.when(client -> client.get("/api/v1/lessons?page=1000001"))
.thenRejectedWith(API, RegistrationErrorCode.VALIDATION_ERROR);
}
@Test
@DisplayName("없는 강의 → 404 LESSON_NOT_FOUND")
void lesson404() {
Scenario.given(api)
.when(client -> client.get("/api/v1/lessons/missing"))
.thenRejectedWith(API, RegistrationErrorCode.LESSON_NOT_FOUND);
}
private static RegistrationErrorCode errorCodeOf(ApiError error) {
RegistrationErrorCode code = RegistrationErrorCode.valueOf(error.code());
assertThat(error.status()).isEqualTo(code.getStatus().value());
return code;
}
}
@@ -0,0 +1,218 @@
package com.study.course_registration.entity;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalTime;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import com.study.course_registration.enums.UserRole;
import com.study.course_registration.support.fixture.DomainFixtures;
import com.study.course_registration.support.fixture.TestData;
class EntityInvariantTest {
@Test
@DisplayName("과목 학점 0 → 생성 거부")
void subjectCredit() {
assertThatThrownBy(() -> new Subject("과목", "CS0", "", 0))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("강의 정원 0 → 생성 거부")
void lessonCapacity() {
assertThatThrownBy(() -> new Lesson(
"강의",
DomainFixtures.subject("CS1"),
DomainFixtures.professor(),
DomainFixtures.openSemester(),
0,
null,
null))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("시간표 시작 >= 종료 → 생성 거부")
void scheduleRange() {
Lesson lesson = DomainFixtures.lesson(
DomainFixtures.subject("CS2"),
DomainFixtures.professor(),
DomainFixtures.openSemester());
assertThatThrownBy(() -> new LessonSchedule(
lesson,
DayOfWeek.MONDAY,
LocalTime.of(11, 0),
LocalTime.of(11, 0)))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("학기 신청 시작 >= 종료 → 생성 거부")
void semesterWindow() {
Instant now = TestData.NOW;
assertThatThrownBy(() -> new Semester(
"학기",
TestData.TODAY,
TestData.TODAY.plusDays(1),
now,
now,
18))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("사용자 학년 0 → 생성 거부")
void userGrade() {
assertThatThrownBy(() -> new User("학생", 0L, UserRole.STUDENT))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("과목 이름 공백 → 생성 거부")
void subjectName() {
assertThatThrownBy(() -> new Subject(" ", "CS", "", 3))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("과목 코드 공백 → 생성 거부")
void subjectCode() {
assertThatThrownBy(() -> new Subject("과목", " ", "", 3))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("강의 이름 공백 → 생성 거부")
void lessonName() {
assertThatThrownBy(() -> new Lesson(
" ",
DomainFixtures.subject("CS"),
DomainFixtures.professor(),
DomainFixtures.openSemester(),
30,
null,
null))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("강의 최소 학년 0 → 생성 거부")
void minGrade() {
assertThatThrownBy(() -> new Lesson(
"강의",
DomainFixtures.subject("CS"),
DomainFixtures.professor(),
DomainFixtures.openSemester(),
30,
0L,
null))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("학기 종료 < 시작 → 생성 거부")
void semesterDates() {
LocalDate today = TestData.TODAY;
Instant now = TestData.NOW;
assertThatThrownBy(() -> new Semester(
"학기",
today,
today.minusDays(1),
now.minusSeconds(1),
now,
18))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("학기 최대 학점 0 → 생성 거부")
void semesterCredits() {
LocalDate today = TestData.TODAY;
Instant now = TestData.NOW;
assertThatThrownBy(() -> new Semester(
"학기",
today,
today.plusDays(1),
now.minusSeconds(1),
now,
0))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("사용자 이름 공백 → 생성 거부")
void userName() {
assertThatThrownBy(() -> new User(" ", 1L, UserRole.STUDENT))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("같은 신청 두 번 취소 → 도메인 거부")
void doubleCancel() {
UserLesson registration = DomainFixtures.registration(
DomainFixtures.student(2),
DomainFixtures.lesson(
DomainFixtures.subject("CS"),
DomainFixtures.professor(),
DomainFixtures.openSemester()));
registration.cancel(TestData.NOW);
assertThatThrownBy(() -> registration.cancel(TestData.NOW))
.isInstanceOf(IllegalStateException.class);
}
@Test
@DisplayName("Idempotency-Key 공백 → 생성 거부")
void idempotencyBlank() {
User user = DomainFixtures.student(2);
Lesson lesson = DomainFixtures.lesson(
DomainFixtures.subject("CS"),
DomainFixtures.professor(),
DomainFixtures.openSemester());
UserLesson registration = DomainFixtures.registration(user, lesson);
assertThatThrownBy(() -> new RegistrationIdempotency(user, lesson, registration, " ", 3, TestData.NOW.plusSeconds(86400)))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("과목 설명 null → 빈 문자열")
void nullSubjectDescription() {
Subject subject = new Subject("과목", "CS-N", null, 3);
assertThat(subject.getDescription()).isEmpty();
}
@Test
@DisplayName("교수 이름 공백 → 생성 거부")
void professorName() {
assertThatThrownBy(() -> new Professor(" "))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("학기 이름 공백 → 생성 거부")
void semesterName() {
LocalDate today = TestData.TODAY;
Instant now = TestData.NOW;
assertThatThrownBy(() -> new Semester(
" ",
today,
today.plusDays(1),
now.minusSeconds(1),
now,
18))
.isInstanceOf(IllegalArgumentException.class);
}
}
@@ -0,0 +1,41 @@
package com.study.course_registration.exception;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.Clock;
import java.time.ZoneOffset;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import com.study.course_registration.support.fixture.TestData;
import jakarta.persistence.LockTimeoutException;
class GlobalExceptionHandlerTest {
private final GlobalExceptionHandler handler =
new GlobalExceptionHandler(Clock.fixed(TestData.NOW, ZoneOffset.UTC));
@Test
@DisplayName("락 타임아웃 → 503 + Retry-After")
void lockTimeout() {
ResponseEntity<ErrorResponse> response = handler.handleLockTimeout(new LockTimeoutException());
assertThat(response.getStatusCode().value()).isEqualTo(503);
assertThat(Integer.parseInt(response.getHeaders().getFirst(HttpHeaders.RETRY_AFTER)))
.isBetween(1, 3);
assertThat(response.getBody().code()).isEqualTo("LOCK_TIMEOUT");
}
@Test
@DisplayName("예상 못한 예외 → 500 공통 에러")
void fallback() {
ResponseEntity<ErrorResponse> response = handler.handleUnexpected(new RuntimeException("boom"));
assertThat(response.getStatusCode().value()).isEqualTo(500);
assertThat(response.getBody().code()).isEqualTo("INTERNAL_SERVER_ERROR");
assertThat(response.getBody().timestamp()).isEqualTo(TestData.NOW);
}
}
@@ -0,0 +1,93 @@
package com.study.course_registration.repository;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.DayOfWeek;
import org.hibernate.Hibernate;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.transaction.PlatformTransactionManager;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.Subject;
import com.study.course_registration.support.PessimisticLockProbe;
import com.study.course_registration.support.PostgresIntegrationTest;
import com.study.course_registration.support.Scenario;
import com.study.course_registration.support.fixture.DatabaseFixture;
import com.study.course_registration.support.fixture.DatabaseFixture.RegistrationDataset;
import com.study.course_registration.support.fixture.DomainFixtures;
class LessonRepositoryTest extends PostgresIntegrationTest {
@Autowired DatabaseFixture fixture;
@Autowired LessonRepository repository;
@Autowired PlatformTransactionManager transactionManager;
private RegistrationDataset data;
@BeforeEach
void setUp() {
data = fixture.registrationDataset();
}
@Test
@DisplayName("findByIdForUpdate → PostgreSQL lesson row lock")
void pessimisticLock() throws Exception {
PessimisticLockProbe.assertSecondTransactionBlocks(
transactionManager,
() -> repository.findByIdForUpdate(data.lesson().getId()).orElseThrow(),
() -> repository.findByIdForUpdate(data.lesson().getId()).orElseThrow());
}
@Test
@DisplayName("상세 조회 → subject·professor·semester graph 초기화")
void detailGraph() {
Scenario.given(data.lesson().getId())
.when(id -> repository.findDetailedById(id).orElseThrow())
.then(lesson -> {
assertThat(Hibernate.isInitialized(lesson.getSubject())).isTrue();
assertThat(Hibernate.isInitialized(lesson.getProfessor())).isTrue();
assertThat(Hibernate.isInitialized(lesson.getSemester())).isTrue();
assertThat(lesson.getSubject().getCode()).isEqualTo(data.subject().getCode());
assertThat(lesson.getProfessor().getId()).isEqualTo(data.professor().getId());
assertThat(lesson.getSemester().getId()).isEqualTo(data.semester().getId());
});
}
@Test
@DisplayName("학기 조회 → 이름·ID 순 정렬")
void semesterPagingAndSort() {
Subject subject = fixture.subject(DomainFixtures.subject("CS200"));
Lesson lesson = fixture.lesson(DomainFixtures.lesson(
null, "AAA 강의", subject, data.professor(), data.semester(), 30, null, null));
fixture.schedule(DomainFixtures.schedule(lesson, DayOfWeek.TUESDAY, 9, 11));
Scenario.given(data)
.when(current -> repository.findBySemester_Id(
current.semester().getId(),
PageRequest.of(0, 20, Sort.by("name").ascending().and(Sort.by("id").ascending()))))
.then(page -> assertThat(page.getContent())
.extracting(Lesson::getName)
.containsExactly("AAA 강의", "CS101 강의"));
}
@Test
@DisplayName("과목 필터 → 해당 과목 강의만 반환")
void subjectFilter() {
Subject other = fixture.subject(DomainFixtures.subject("CS300"));
Lesson lesson = fixture.lesson(DomainFixtures.lesson(other, data.professor(), data.semester()));
fixture.schedule(DomainFixtures.schedule(lesson, DayOfWeek.FRIDAY, 9, 11));
Scenario.given(other.getId())
.when(subjectId -> repository.findBySemester_IdAndSubject_Id(
data.semester().getId(), subjectId, PageRequest.of(0, 20)))
.then(page -> assertThat(page.getContent())
.extracting(Lesson::getId)
.containsExactly(lesson.getId()));
}
}
@@ -0,0 +1,56 @@
package com.study.course_registration.repository;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.DayOfWeek;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.entity.Subject;
import com.study.course_registration.support.PostgresIntegrationTest;
import com.study.course_registration.support.Scenario;
import com.study.course_registration.support.fixture.DatabaseFixture;
import com.study.course_registration.support.fixture.DatabaseFixture.RegistrationDataset;
import com.study.course_registration.support.fixture.DomainFixtures;
class LessonScheduleRepositoryTest extends PostgresIntegrationTest {
@Autowired DatabaseFixture fixture;
@Autowired LessonScheduleRepository repository;
private RegistrationDataset data;
@BeforeEach
void setUp() {
data = fixture.registrationDataset();
}
@Test
@DisplayName("lesson IDs bulk 조회 → 요일·시작시각 순 정렬")
void bulkAndOrdering() {
Subject subject = fixture.subject(DomainFixtures.subject("CS200"));
Lesson other = fixture.lesson(DomainFixtures.lesson(subject, data.professor(), data.semester()));
fixture.schedule(DomainFixtures.schedule(other, DayOfWeek.WEDNESDAY, 13, 15));
fixture.schedule(DomainFixtures.schedule(other, DayOfWeek.TUESDAY, 15, 17));
fixture.schedule(DomainFixtures.schedule(other, DayOfWeek.TUESDAY, 9, 11));
List<String> lessonIds = List.of(data.lesson().getId(), other.getId());
Scenario.given(lessonIds)
.when(repository::findByLesson_IdInOrderByDayOfWeekAscStartTimeAsc)
.then(schedules -> assertThat(schedules)
.extracting(
schedule -> schedule.getDayOfWeek().name(),
schedule -> schedule.getStartTime().toString())
.containsExactly(
org.assertj.core.groups.Tuple.tuple("MONDAY", "09:00"),
org.assertj.core.groups.Tuple.tuple("TUESDAY", "09:00"),
org.assertj.core.groups.Tuple.tuple("TUESDAY", "15:00"),
org.assertj.core.groups.Tuple.tuple("WEDNESDAY", "13:00")));
}
}
@@ -0,0 +1,172 @@
package com.study.course_registration.repository;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.time.DayOfWeek;
import java.time.Instant;
import org.hibernate.Hibernate;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataIntegrityViolationException;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.RegistrationIdempotency;
import com.study.course_registration.entity.Subject;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.support.PostgresIntegrationTest;
import com.study.course_registration.support.Scenario;
import com.study.course_registration.support.fixture.DatabaseFixture;
import com.study.course_registration.support.fixture.DatabaseFixture.RegistrationDataset;
import com.study.course_registration.support.fixture.DomainFixtures;
import com.study.course_registration.support.fixture.TestData;
class RegistrationIdempotencyRepositoryTest extends PostgresIntegrationTest {
@Autowired DatabaseFixture fixture;
@Autowired RegistrationIdempotencyRepository repository;
private RegistrationDataset data;
private UserLesson registration;
@BeforeEach
void setUp() {
data = fixture.registrationDataset();
registration = fixture.registration(
DomainFixtures.registration(data.student(), data.lesson()));
}
@Test
@DisplayName("userId + key + 유효기간 조회 → 연관 graph와 lifecycle 로드")
void lookupGraph() {
Instant expiresAt = TestData.NOW.plusSeconds(86400);
repository.saveAndFlush(idempotency("request-1", registration, data.lesson(), expiresAt));
Scenario.given("request-1")
.when(key -> repository
.findByUser_IdAndIdempotencyKeyAndExpiresAtAfter(
data.student().getId(),
key,
TestData.NOW)
.orElseThrow())
.then(stored -> {
assertThat(Hibernate.isInitialized(stored.getUser())).isTrue();
assertThat(Hibernate.isInitialized(stored.getLesson())).isTrue();
assertThat(Hibernate.isInitialized(stored.getLesson().getSubject())).isTrue();
assertThat(Hibernate.isInitialized(stored.getRegistration())).isTrue();
assertThat(stored.getCreatedAt()).isNotNull();
assertThat(stored.getExpiresAt()).isEqualTo(expiresAt);
});
}
@Test
@DisplayName("만료 key 삭제 → 같은 user + key 재사용 가능")
void expiredKeyCanBeRemoved() {
Instant expiredAt = TestData.NOW.minusSeconds(1);
repository.saveAndFlush(idempotency("request-expired", registration, data.lesson(), expiredAt));
Scenario.given("request-expired")
.when(key -> repository.deleteExpiredKey(
data.student().getId(),
key,
TestData.NOW))
.then(deleted -> {
assertThat(deleted).isEqualTo(1);
assertThat(repository.findAll()).isEmpty();
});
}
@Test
@DisplayName("만료 전체 정리 → expiresAt 지난 행만 삭제")
void deleteExpired() {
repository.saveAndFlush(idempotency(
"expired",
registration,
data.lesson(),
TestData.NOW.minusSeconds(1)));
Subject subject = fixture.subject(DomainFixtures.subject("FRESH"));
Lesson freshLesson = fixture.lesson(
DomainFixtures.lesson(subject, data.professor(), data.semester()));
fixture.schedule(DomainFixtures.schedule(freshLesson, DayOfWeek.TUESDAY, 13, 15));
UserLesson freshRegistration = fixture.registration(
DomainFixtures.registration(data.student(), freshLesson));
repository.saveAndFlush(new RegistrationIdempotency(
data.student(),
freshLesson,
freshRegistration,
"fresh",
6,
TestData.NOW.plusSeconds(86400)));
Scenario.given(TestData.NOW)
.when(repository::deleteExpired)
.then(deleted -> {
assertThat(deleted).isEqualTo(1);
assertThat(repository.findAll())
.extracting(RegistrationIdempotency::getIdempotencyKey)
.containsExactly("fresh");
});
}
@Test
@DisplayName("같은 user + key → DB unique 거부")
void userKeyUnique() {
repository.saveAndFlush(idempotency(
"request-1",
registration,
data.lesson(),
TestData.NOW.plusSeconds(86400)));
Subject subject = fixture.subject(DomainFixtures.subject("OTHER"));
Lesson otherLesson = fixture.lesson(
DomainFixtures.lesson(subject, data.professor(), data.semester()));
fixture.schedule(DomainFixtures.schedule(otherLesson, DayOfWeek.TUESDAY, 13, 15));
UserLesson otherRegistration =
fixture.registration(DomainFixtures.registration(data.student(), otherLesson));
assertThatThrownBy(() -> repository.saveAndFlush(new RegistrationIdempotency(
data.student(),
otherLesson,
otherRegistration,
"request-1",
6,
TestData.NOW.plusSeconds(86400))))
.isInstanceOf(DataIntegrityViolationException.class);
}
@Test
@DisplayName("같은 registration + 다른 key → DB unique 거부")
void registrationUnique() {
repository.saveAndFlush(idempotency(
"request-1",
registration,
data.lesson(),
TestData.NOW.plusSeconds(86400)));
assertThatThrownBy(() -> repository.saveAndFlush(new RegistrationIdempotency(
data.student(),
data.lesson(),
registration,
"request-2",
3,
TestData.NOW.plusSeconds(86400))))
.isInstanceOf(DataIntegrityViolationException.class);
}
private RegistrationIdempotency idempotency(
String key,
UserLesson target,
Lesson lesson,
Instant expiresAt) {
return new RegistrationIdempotency(
data.student(),
lesson,
target,
key,
3,
expiresAt);
}
}
@@ -0,0 +1,52 @@
package com.study.course_registration.repository;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.support.PostgresIntegrationTest;
import com.study.course_registration.support.Scenario;
import com.study.course_registration.support.fixture.DatabaseFixture;
import com.study.course_registration.support.fixture.DomainFixtures;
import com.study.course_registration.support.fixture.TestData;
class SemesterRepositoryTest extends PostgresIntegrationTest {
@Autowired DatabaseFixture fixture;
@Autowired SemesterRepository repository;
@BeforeEach
void setUp() {
fixture.reset();
}
@Test
@DisplayName("신청 기간 포함 조회 → 활성 학기 반환")
void findRegistrationWindow() {
Semester semester = fixture.semester(DomainFixtures.futureAcademicSemesterWithOpenRegistration());
Scenario.given(TestData.NOW)
.when(now -> repository
.findByRegistrationStartAtLessThanEqualAndRegistrationEndAtGreaterThanEqual(now, now))
.then(result -> assertThat(result)
.extracting(Semester::getId)
.containsExactly(semester.getId()));
}
@Test
@DisplayName("학사 기간 포함 조회 → 진행 학기 반환")
void findAcademicWindow() {
Semester semester = fixture.semester(DomainFixtures.academicSemester("academic"));
Scenario.given(TestData.TODAY)
.when(today -> repository.findByStartDateLessThanEqualAndEndDateGreaterThanEqual(today, today))
.then(result -> assertThat(result)
.extracting(Semester::getId)
.containsExactly(semester.getId()));
}
}
@@ -0,0 +1,136 @@
package com.study.course_registration.repository;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.time.DayOfWeek;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataIntegrityViolationException;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.entity.Subject;
import com.study.course_registration.entity.User;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.support.PostgresIntegrationTest;
import com.study.course_registration.support.Scenario;
import com.study.course_registration.support.fixture.DatabaseFixture;
import com.study.course_registration.support.fixture.DatabaseFixture.RegistrationDataset;
import com.study.course_registration.support.fixture.DomainFixtures;
import com.study.course_registration.support.fixture.TestData;
class UserLessonRepositoryTest extends PostgresIntegrationTest {
@Autowired DatabaseFixture fixture;
@Autowired UserLessonRepository repository;
private RegistrationDataset data;
@BeforeEach
void setUp() {
data = fixture.registrationDataset();
}
@Test
@DisplayName("유효 신청 조회 → 같은 학기·미취소만 반환")
void activeBySemester() {
fixture.registration(DomainFixtures.registration(data.student(), data.lesson()));
Semester otherSemester = fixture.semester(DomainFixtures.semester(
null,
"2027-1",
TestData.TODAY.plusDays(100),
TestData.TODAY.plusDays(200),
-3600,
3600,
18));
Subject otherSubject = fixture.subject(DomainFixtures.subject("OTHER"));
Lesson otherLesson = fixture.lesson(
DomainFixtures.lesson(otherSubject, data.professor(), otherSemester));
fixture.schedule(DomainFixtures.schedule(otherLesson, DayOfWeek.TUESDAY, 9, 11));
fixture.registration(DomainFixtures.registration(data.student(), otherLesson));
Subject canceledSubject = fixture.subject(DomainFixtures.subject("CANCEL"));
Lesson canceledLesson = fixture.lesson(
DomainFixtures.lesson(canceledSubject, data.professor(), data.semester()));
fixture.schedule(DomainFixtures.schedule(canceledLesson, DayOfWeek.WEDNESDAY, 9, 11));
UserLesson canceled = fixture.registration(
DomainFixtures.registration(data.student(), canceledLesson));
canceled.cancel(TestData.NOW);
repository.saveAndFlush(canceled);
Scenario.given(data)
.when(current -> repository.findActiveByUserIdAndSemesterId(
current.student().getId(),
current.semester().getId()))
.then(result -> assertThat(result)
.extracting(registration -> registration.getLesson().getId())
.containsExactly(data.lesson().getId()));
}
@Test
@DisplayName("유효 신청 중복 → DB unique 거부")
void activeDuplicateIsRejected() {
fixture.registration(DomainFixtures.registration(data.student(), data.lesson()));
assertThatThrownBy(() -> fixture.registration(
DomainFixtures.registration(data.student(), data.lesson())))
.isInstanceOf(DataIntegrityViolationException.class);
}
@Test
@DisplayName("취소 후 같은 강의 재신청 → 허용")
void canceledThenRegisterAgain() {
UserLesson first = fixture.registration(
DomainFixtures.registration(data.student(), data.lesson()));
first.cancel(TestData.NOW);
repository.saveAndFlush(first);
Scenario.given(first)
.when(previous -> fixture.registration(
DomainFixtures.registration(data.student(), data.lesson())))
.then(second -> {
assertThat(second.getId()).isNotEqualTo(first.getId());
assertThat(repository.countByLesson_IdAndCanceledAtIsNull(data.lesson().getId()))
.isEqualTo(1);
});
}
@Test
@DisplayName("강의별 신청 수 집계 → 취소 건 제외")
void aggregateCountsExcludeCanceled() {
fixture.registration(DomainFixtures.registration(data.student(), data.lesson()));
User other = fixture.user(DomainFixtures.student(3));
UserLesson canceled = fixture.registration(
DomainFixtures.registration(other, data.lesson()));
canceled.cancel(TestData.NOW);
repository.saveAndFlush(canceled);
Scenario.given(List.of(data.lesson().getId()))
.when(repository::countActiveByLessonIds)
.then(counts -> assertThat(counts)
.singleElement()
.satisfies(count -> {
assertThat(count.getLessonId()).isEqualTo(data.lesson().getId());
assertThat(count.getEnrolledCount()).isEqualTo(1);
}));
}
@Test
@DisplayName("취소 대상 projection → userId·lessonId 반환")
void targetProjection() {
UserLesson registration = fixture.registration(
DomainFixtures.registration(data.student(), data.lesson()));
Scenario.given(registration.getId())
.when(id -> repository.findTargetById(id).orElseThrow())
.then(target -> {
assertThat(target.getUserId()).isEqualTo(data.student().getId());
assertThat(target.getLessonId()).isEqualTo(data.lesson().getId());
});
}
}
@@ -0,0 +1,34 @@
package com.study.course_registration.repository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.PlatformTransactionManager;
import com.study.course_registration.support.PessimisticLockProbe;
import com.study.course_registration.support.PostgresIntegrationTest;
import com.study.course_registration.support.fixture.DatabaseFixture;
import com.study.course_registration.support.fixture.DatabaseFixture.RegistrationDataset;
class UserRepositoryTest extends PostgresIntegrationTest {
@Autowired DatabaseFixture fixture;
@Autowired UserRepository repository;
@Autowired PlatformTransactionManager transactionManager;
private RegistrationDataset data;
@BeforeEach
void setUp() {
data = fixture.registrationDataset();
}
@Test
@DisplayName("findByIdForUpdate → PostgreSQL user row lock")
void pessimisticLock() throws Exception {
PessimisticLockProbe.assertSecondTransactionBlocks(
transactionManager,
() -> repository.findByIdForUpdate(data.student().getId()).orElseThrow(),
() -> repository.findByIdForUpdate(data.student().getId()).orElseThrow());
}
}
@@ -0,0 +1,53 @@
package com.study.course_registration.seeder;
import java.time.Clock;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.repository.LessonRepository;
import com.study.course_registration.repository.SemesterRepository;
import com.study.course_registration.repository.UserRepository;
@SpringBootTest
@ActiveProfiles("local")
class DataSeederTest {
@Autowired DataSeeder seeder;
@Autowired Clock clock;
@Autowired SemesterRepository semesters;
@Autowired LessonRepository lessons;
@Autowired UserRepository users;
@Test
@DisplayName("local seed → 학기 1·강의 7·사용자 3")
void loadsDataset() {
assertThat(semesters.count()).isEqualTo(1);
assertThat(lessons.count()).isEqualTo(7);
assertThat(users.count()).isEqualTo(3);
}
@Test
@DisplayName("local seed → 신청 기간이 현재 시각 포함")
void registrationWindowContainsNow() {
Semester semester = semesters.findById(DataSeeder.SEMESTER_ID).orElseThrow();
assertThat(semester.getRegistrationStartAt()).isBefore(clock.instant());
assertThat(semester.getRegistrationEndAt()).isAfter(clock.instant());
}
@Test
@DisplayName("seed 재실행 → 데이터 중복 없음")
void rerunIsIdempotent() throws Exception {
seeder.run();
assertThat(semesters.count()).isEqualTo(1);
assertThat(lessons.count()).isEqualTo(7);
assertThat(users.count()).isEqualTo(3);
}
}
@@ -0,0 +1,33 @@
package com.study.course_registration.seeder;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
class SeedTableTest {
@Test
@DisplayName("TSV 읽기 → 문자열·nullable·숫자 변환")
void read() {
SeedTable.Row row = SeedTable.read("seed/test/valid.tsv").getFirst();
assertThat(row.text("name")).isEqualTo("alpha");
assertThat(row.nullable("optional")).isNull();
assertThat(row.integer("number")).isEqualTo(3);
}
@Test
@DisplayName("컬럼 수 불일치 → 로드 실패")
void malformed() {
assertThatThrownBy(() -> SeedTable.read("seed/test/malformed.tsv"))
.isInstanceOf(IllegalStateException.class);
}
@Test
@DisplayName("리소스 없음 → 로드 실패")
void missing() {
assertThatThrownBy(() -> SeedTable.read("seed/test/missing.tsv"))
.isInstanceOf(IllegalStateException.class);
}
}
@@ -3,9 +3,6 @@ package com.study.course_registration.service;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
@@ -16,34 +13,27 @@ import java.util.concurrent.TimeUnit;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import com.study.course_registration.dto.registration.CourseRegistrationRequest;
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.entity.User;
import com.study.course_registration.enums.RegistrationErrorCode;
import com.study.course_registration.enums.UserRole;
import com.study.course_registration.exception.RegistrationException;
import com.study.course_registration.repository.*;
import com.study.course_registration.repository.UserLessonRepository;
import com.study.course_registration.support.PostgresIntegrationTest;
import com.study.course_registration.support.Scenario;
import com.study.course_registration.support.fixture.DatabaseFixture;
import com.study.course_registration.support.fixture.DomainFixtures;
@SpringBootTest
@ActiveProfiles("test")
class CourseRegistrationConcurrencyIntegrationTest {
class CourseRegistrationConcurrencyIntegrationTest extends PostgresIntegrationTest {
@Autowired CourseRegistrationService service;
@Autowired UserLessonRepository userLessonRepository;
@Autowired LessonScheduleRepository lessonScheduleRepository;
@Autowired LessonRepository lessonRepository;
@Autowired SubjectRepository subjectRepository;
@Autowired ProfessorRepository professorRepository;
@Autowired SemesterRepository semesterRepository;
@Autowired UserRepository userRepository;
@Autowired DatabaseFixture fixture;
@Autowired UserLessonRepository registrations;
private ExecutorService executor;
private Semester semester;
@@ -51,11 +41,9 @@ class CourseRegistrationConcurrencyIntegrationTest {
@BeforeEach
void setUp() {
clearData();
Instant now = Instant.now();
semester = semesterRepository.save(new Semester("semester", "2026-1", LocalDate.now().minusDays(1),
LocalDate.now().plusDays(100), now.minusSeconds(3600), now.plusSeconds(3600), 18));
professor = professorRepository.save(new Professor("professor", "교수"));
fixture.reset();
semester = fixture.semester(DomainFixtures.openSemester());
professor = fixture.professor(DomainFixtures.professor());
}
@AfterEach
@@ -67,108 +55,123 @@ class CourseRegistrationConcurrencyIntegrationTest {
}
@Test
void capacityOneWithTenConcurrentUsersHasExactlyOneSuccess() throws Exception {
Lesson lesson = lesson("lesson-cap1", "subject-cap1", 3, 1, DayOfWeek.MONDAY, 9, 11);
List<User> users = users(10, "cap1-user-");
List<RegistrationErrorCode> results = runConcurrent(users.stream()
.<ThrowingAction>map(user -> () -> service.register(user.getId(), new CourseRegistrationRequest(lesson.getId())))
.toList());
assertThat(results.stream().filter(code -> code == null)).hasSize(1);
assertThat(results.stream().filter(code -> code == RegistrationErrorCode.CAPACITY_EXCEEDED)).hasSize(9);
assertThat(userLessonRepository.countByLesson_IdAndCanceledAtIsNull(lesson.getId())).isEqualTo(1);
@DisplayName("정원 1 + 동시 10명 → 성공 1")
void capacityOne() {
Lesson lesson = fixture.scheduledLesson(
semester, professor, "CAP1", 3, 1, DayOfWeek.MONDAY, 9, 11);
List<User> users = fixture.students(10, "cap1-");
List<ThrowingAction> actions = users.stream()
.<ThrowingAction>map(user -> () -> service.register(
user.getId(),
new CourseRegistrationRequest(lesson.getId())))
.toList();
Scenario.given(actions)
.when(this::run)
.then(outcome -> {
assertThat(outcome.acceptedCount()).isEqualTo(1);
assertThat(outcome.rejectedCount(RegistrationErrorCode.CAPACITY_EXCEEDED)).isEqualTo(9);
assertThat(registrations.countByLesson_IdAndCanceledAtIsNull(lesson.getId())).isEqualTo(1);
});
}
@Test
void sameStudentConcurrentLessonsCannotExceedCreditLimit() throws Exception {
replaceSemesterWithMaxCredits(3);
User user = userRepository.save(new User("credit-user", "학생", 2L, UserRole.STUDENT));
Lesson lessonA = lesson("credit-a", "credit-subject-a", 3, 30, DayOfWeek.MONDAY, 9, 11);
Lesson lessonB = lesson("credit-b", "credit-subject-b", 3, 30, DayOfWeek.TUESDAY, 9, 11);
List<RegistrationErrorCode> results = runConcurrent(List.of(
() -> service.register(user.getId(), new CourseRegistrationRequest(lessonA.getId())),
() -> service.register(user.getId(), new CourseRegistrationRequest(lessonB.getId()))));
assertThat(results.stream().filter(code -> code == null)).hasSize(1);
assertThat(results.stream().filter(code -> code == RegistrationErrorCode.CREDIT_LIMIT_EXCEEDED)).hasSize(1);
@DisplayName("정원 30 + 동시 50명 → 성공 30")
void capacityThirty() {
Lesson lesson = fixture.scheduledLesson(
semester, professor, "CAP30", 3, 30, DayOfWeek.THURSDAY, 9, 11);
List<User> users = fixture.students(50, "cap30-");
List<ThrowingAction> actions = users.stream()
.<ThrowingAction>map(user -> () -> service.register(
user.getId(),
new CourseRegistrationRequest(lesson.getId())))
.toList();
Scenario.given(actions)
.when(this::run)
.then(outcome -> {
assertThat(outcome.acceptedCount()).isEqualTo(30);
assertThat(outcome.rejectedCount(RegistrationErrorCode.CAPACITY_EXCEEDED)).isEqualTo(20);
assertThat(registrations.countByLesson_IdAndCanceledAtIsNull(lesson.getId())).isEqualTo(30);
});
}
@Test
void sameStudentConcurrentOverlappingLessonsRejectOneConflict() throws Exception {
User user = userRepository.save(new User("schedule-user", "학생", 2L, UserRole.STUDENT));
Lesson lessonA = lesson("schedule-a", "schedule-subject-a", 3, 30, DayOfWeek.MONDAY, 9, 11);
Lesson lessonB = lesson("schedule-b", "schedule-subject-b", 3, 30, DayOfWeek.MONDAY, 10, 12);
List<RegistrationErrorCode> results = runConcurrent(List.of(
() -> service.register(user.getId(), new CourseRegistrationRequest(lessonA.getId())),
() -> service.register(user.getId(), new CourseRegistrationRequest(lessonB.getId()))));
assertThat(results.stream().filter(code -> code == null)).hasSize(1);
assertThat(results.stream().filter(code -> code == RegistrationErrorCode.SCHEDULE_CONFLICT)).hasSize(1);
@DisplayName("동일 학생 + 잔여 3학점 + 동시 2강의 → 성공 1")
void creditLimit() {
fixture.reset();
semester = fixture.semester(DomainFixtures.openSemester(3));
professor = fixture.professor(DomainFixtures.professor());
User user = fixture.user(DomainFixtures.student(2));
Lesson first = fixture.scheduledLesson(
semester, professor, "CR1", 3, 30, DayOfWeek.MONDAY, 9, 11);
Lesson second = fixture.scheduledLesson(
semester, professor, "CR2", 3, 30, DayOfWeek.TUESDAY, 9, 11);
Scenario.given(List.<ThrowingAction>of(
() -> service.register(
user.getId(),
new CourseRegistrationRequest(first.getId())),
() -> service.register(
user.getId(),
new CourseRegistrationRequest(second.getId()))))
.when(this::run)
.then(outcome -> {
assertThat(outcome.acceptedCount()).isEqualTo(1);
assertThat(outcome.rejectedCount(RegistrationErrorCode.CREDIT_LIMIT_EXCEEDED)).isEqualTo(1);
});
}
@Test
void sameStudentSameLessonConcurrentRequestsRejectDuplicate() throws Exception {
User user = userRepository.save(new User("duplicate-user", "학생", 2L, UserRole.STUDENT));
Lesson lesson = lesson("duplicate-lesson", "duplicate-subject", 3, 30, DayOfWeek.WEDNESDAY, 9, 11);
List<RegistrationErrorCode> results = runConcurrent(List.of(
() -> service.register(user.getId(), new CourseRegistrationRequest(lesson.getId())),
() -> service.register(user.getId(), new CourseRegistrationRequest(lesson.getId()))));
assertThat(results.stream().filter(code -> code == null)).hasSize(1);
assertThat(results.stream().filter(code -> code == RegistrationErrorCode.ALREADY_REGISTERED)).hasSize(1);
@DisplayName("동일 학생 + 겹치는 2강의 동시 신청 → 성공 1")
void scheduleConflict() {
User user = fixture.user(DomainFixtures.student(2));
Lesson first = fixture.scheduledLesson(
semester, professor, "SC1", 3, 30, DayOfWeek.MONDAY, 9, 11);
Lesson second = fixture.scheduledLesson(
semester, professor, "SC2", 3, 30, DayOfWeek.MONDAY, 10, 12);
Scenario.given(List.<ThrowingAction>of(
() -> service.register(
user.getId(),
new CourseRegistrationRequest(first.getId())),
() -> service.register(
user.getId(),
new CourseRegistrationRequest(second.getId()))))
.when(this::run)
.then(outcome -> {
assertThat(outcome.acceptedCount()).isEqualTo(1);
assertThat(outcome.rejectedCount(RegistrationErrorCode.SCHEDULE_CONFLICT)).isEqualTo(1);
});
}
@Test
void capacityThirtyWithFiftyConcurrentUsersStopsAtThirty() throws Exception {
Lesson lesson = lesson("lesson-cap30", "subject-cap30", 3, 30, DayOfWeek.THURSDAY, 9, 11);
List<User> users = users(50, "cap30-user-");
List<RegistrationErrorCode> results = runConcurrent(users.stream()
.<ThrowingAction>map(user -> () -> service.register(user.getId(), new CourseRegistrationRequest(lesson.getId())))
.toList());
assertThat(results.stream().filter(code -> code == null)).hasSize(30);
assertThat(results.stream().filter(code -> code == RegistrationErrorCode.CAPACITY_EXCEEDED)).hasSize(20);
assertThat(userLessonRepository.countByLesson_IdAndCanceledAtIsNull(lesson.getId())).isEqualTo(30);
@DisplayName("동일 학생 + 동일 강의 동시 신청 → 성공 1")
void duplicateLesson() {
User user = fixture.user(DomainFixtures.student(2));
Lesson lesson = fixture.scheduledLesson(
semester, professor, "DUP", 3, 30, DayOfWeek.WEDNESDAY, 9, 11);
Scenario.given(List.<ThrowingAction>of(
() -> service.register(
user.getId(),
new CourseRegistrationRequest(lesson.getId())),
() -> service.register(
user.getId(),
new CourseRegistrationRequest(lesson.getId()))))
.when(this::run)
.then(outcome -> {
assertThat(outcome.acceptedCount()).isEqualTo(1);
assertThat(outcome.rejectedCount(RegistrationErrorCode.ALREADY_REGISTERED)).isEqualTo(1);
});
}
private void replaceSemesterWithMaxCredits(int maxCredits) {
userLessonRepository.deleteAll();
lessonScheduleRepository.deleteAll();
lessonRepository.deleteAll();
semesterRepository.deleteAll();
Instant now = Instant.now();
semester = semesterRepository.save(new Semester("semester", "2026-1", LocalDate.now().minusDays(1),
LocalDate.now().plusDays(100), now.minusSeconds(3600), now.plusSeconds(3600), maxCredits));
}
private void clearData() {
userLessonRepository.deleteAll();
lessonScheduleRepository.deleteAll();
lessonRepository.deleteAll();
subjectRepository.deleteAll();
professorRepository.deleteAll();
semesterRepository.deleteAll();
userRepository.deleteAll();
}
private Lesson lesson(String lessonId, String subjectId, int credit, int capacity,
DayOfWeek day, int startHour, int endHour) {
Subject subject = subjectRepository.save(new Subject(subjectId, subjectId, subjectId, subjectId, credit));
Lesson lesson = lessonRepository.save(new Lesson(lessonId, lessonId, subject, professor, semester, capacity, null, null));
lessonScheduleRepository.save(new LessonSchedule("schedule-" + lessonId, lesson, day,
LocalTime.of(startHour, 0), LocalTime.of(endHour, 0)));
return lesson;
}
private List<User> users(int count, String prefix) {
List<User> users = new ArrayList<>();
for (int index = 0; index < count; index++) {
users.add(new User(prefix + index, "학생" + index, 2L, UserRole.STUDENT));
}
return userRepository.saveAll(users);
}
private List<RegistrationErrorCode> runConcurrent(List<ThrowingAction> actions) throws Exception {
private ConcurrentOutcome run(List<ThrowingAction> actions) {
executor = Executors.newFixedThreadPool(actions.size());
CountDownLatch ready = new CountDownLatch(actions.size());
CountDownLatch start = new CountDownLatch(1);
CountDownLatch done = new CountDownLatch(actions.size());
List<RegistrationErrorCode> results = Collections.synchronizedList(new ArrayList<>());
List<AttemptResult> results = Collections.synchronizedList(new ArrayList<>());
List<Throwable> unexpected = Collections.synchronizedList(new ArrayList<>());
for (ThrowingAction action : actions) {
@@ -177,9 +180,9 @@ class CourseRegistrationConcurrencyIntegrationTest {
try {
start.await();
action.run();
results.add(null);
results.add(new Accepted());
} catch (RegistrationException exception) {
results.add(exception.getErrorCode());
results.add(new Rejected(exception.getErrorCode()));
} catch (Throwable throwable) {
unexpected.add(throwable);
} finally {
@@ -188,11 +191,39 @@ class CourseRegistrationConcurrencyIntegrationTest {
});
}
assertThat(ready.await(10, TimeUnit.SECONDS)).isTrue();
start.countDown();
assertThat(done.await(30, TimeUnit.SECONDS)).isTrue();
try {
assertThat(ready.await(10, TimeUnit.SECONDS)).isTrue();
start.countDown();
assertThat(done.await(30, TimeUnit.SECONDS)).isTrue();
} catch (InterruptedException interrupted) {
Thread.currentThread().interrupt();
throw new AssertionError("동시성 테스트가 중단되었습니다.", interrupted);
}
assertThat(unexpected).isEmpty();
return results;
return new ConcurrentOutcome(List.copyOf(results));
}
private sealed interface AttemptResult permits Accepted, Rejected {
}
private record Accepted() implements AttemptResult {
}
private record Rejected(RegistrationErrorCode code) implements AttemptResult {
}
private record ConcurrentOutcome(List<AttemptResult> attempts) {
long acceptedCount() {
return attempts.stream().filter(Accepted.class::isInstance).count();
}
long rejectedCount(RegistrationErrorCode code) {
return attempts.stream()
.filter(Rejected.class::isInstance)
.map(Rejected.class::cast)
.filter(rejected -> rejected.code() == code)
.count();
}
}
@FunctionalInterface
@@ -1,171 +1,281 @@
package com.study.course_registration.service;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalTime;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import com.study.course_registration.dto.registration.CourseRegistrationRequest;
import com.study.course_registration.dto.registration.CourseRegistrationResponse;
import com.study.course_registration.dto.registration.RegistrationListResponse;
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.entity.User;
import com.study.course_registration.enums.RegistrationErrorCode;
import com.study.course_registration.enums.UserRole;
import com.study.course_registration.exception.RegistrationException;
import com.study.course_registration.repository.LessonRepository;
import com.study.course_registration.repository.LessonScheduleRepository;
import com.study.course_registration.repository.ProfessorRepository;
import com.study.course_registration.repository.SemesterRepository;
import com.study.course_registration.repository.SubjectRepository;
import com.study.course_registration.repository.UserLessonRepository;
import com.study.course_registration.repository.UserRepository;
import com.study.course_registration.support.PostgresIntegrationTest;
import com.study.course_registration.support.Rejections;
import com.study.course_registration.support.Scenario;
import com.study.course_registration.support.fixture.DatabaseFixture;
import com.study.course_registration.support.fixture.DatabaseFixture.RegistrationDataset;
import com.study.course_registration.support.fixture.DomainFixtures;
import com.study.course_registration.support.fixture.TestData;
class CourseRegistrationServiceIntegrationTest extends PostgresIntegrationTest {
private static final Rejections<RegistrationException, RegistrationErrorCode> REJECTIONS =
Rejections.of(RegistrationException.class, RegistrationException::getErrorCode);
@SpringBootTest
@ActiveProfiles("test")
class CourseRegistrationServiceIntegrationTest {
@Autowired CourseRegistrationService service;
@Autowired UserLessonRepository userLessonRepository;
@Autowired LessonScheduleRepository lessonScheduleRepository;
@Autowired LessonRepository lessonRepository;
@Autowired SubjectRepository subjectRepository;
@Autowired ProfessorRepository professorRepository;
@Autowired SemesterRepository semesterRepository;
@Autowired UserRepository userRepository;
@Autowired DatabaseFixture fixture;
@Autowired UserLessonRepository registrations;
private Semester semester;
private User user;
private Subject subjectA;
private Subject subjectB;
private Professor professor;
private Lesson lessonA;
private Lesson lessonB;
private RegistrationDataset data;
@BeforeEach
void setUp() {
userLessonRepository.deleteAll();
lessonScheduleRepository.deleteAll();
lessonRepository.deleteAll();
subjectRepository.deleteAll();
professorRepository.deleteAll();
semesterRepository.deleteAll();
userRepository.deleteAll();
Instant now = Instant.now();
semester = semesterRepository.save(new Semester("semester", "2026-1", LocalDate.now().minusDays(1),
LocalDate.now().plusDays(100), now.minusSeconds(3600), now.plusSeconds(3600), 18));
professor = professorRepository.save(new Professor("professor", "교수"));
subjectA = subjectRepository.save(new Subject("subject-a", "과목A", "A101", "A", 3));
subjectB = subjectRepository.save(new Subject("subject-b", "과목B", "B101", "B", 3));
user = userRepository.save(new User("user", "학생", 2L, UserRole.STUDENT));
lessonA = lessonRepository.save(new Lesson("lesson-a", "강의A", subjectA, professor, semester, 30, null, null));
lessonB = lessonRepository.save(new Lesson("lesson-b", "강의B", subjectB, professor, semester, 30, null, null));
lessonScheduleRepository.save(new LessonSchedule("schedule-a", lessonA, DayOfWeek.MONDAY, LocalTime.of(9, 0), LocalTime.of(11, 0)));
lessonScheduleRepository.save(new LessonSchedule("schedule-b", lessonB, DayOfWeek.TUESDAY, LocalTime.of(9, 0), LocalTime.of(11, 0)));
data = fixture.registrationDataset();
}
@Test
void registerCreatesActiveRegistrationAndReturnsTotalCredits() {
CourseRegistrationResponse response = service.register(user.getId(), new CourseRegistrationRequest(lessonA.getId()));
assertThat(response.userId()).isEqualTo(user.getId());
assertThat(response.lessonId()).isEqualTo(lessonA.getId());
assertThat(response.totalCredits()).isEqualTo(3);
assertThat(userLessonRepository.countByLesson_IdAndCanceledAtIsNull(lessonA.getId())).isEqualTo(1);
@DisplayName("신청 성공 → 유효 신청 1건")
void register() {
Scenario.given(data)
.when(current -> service.register(
current.student().getId(),
new CourseRegistrationRequest(current.lesson().getId())))
.then(response -> {
assertThat(response.totalCredits()).isEqualTo(3);
assertThat(response.registeredAt()).isEqualTo(TestData.NOW);
assertThat(registrations.countByLesson_IdAndCanceledAtIsNull(data.lesson().getId()))
.isEqualTo(1);
});
}
@Test
void duplicateRegistrationIsRejected() {
service.register(user.getId(), new CourseRegistrationRequest(lessonA.getId()));
@DisplayName("같은 강의 재신청 → ALREADY_REGISTERED")
void duplicate() {
service.register(data.student().getId(), new CourseRegistrationRequest(data.lesson().getId()));
assertThatThrownBy(() -> service.register(user.getId(), new CourseRegistrationRequest(lessonA.getId())))
.isInstanceOfSatisfying(RegistrationException.class,
ex -> assertThat(ex.getErrorCode()).isEqualTo(RegistrationErrorCode.ALREADY_REGISTERED));
Scenario.given(data)
.when(current -> service.register(
current.student().getId(),
new CourseRegistrationRequest(current.lesson().getId())))
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.ALREADY_REGISTERED);
}
@Test
void cancelThenReregisterKeepsHistoryAndOneActiveRow() {
CourseRegistrationResponse first = service.register(user.getId(), new CourseRegistrationRequest(lessonA.getId()));
service.cancel(user.getId(), first.registrationId());
@DisplayName("취소 후 재신청 → 이력 2건, 유효 1건")
void cancelAndRegisterAgain() {
CourseRegistrationResponse first = service.register(
data.student().getId(),
new CourseRegistrationRequest(data.lesson().getId()));
service.cancel(data.student().getId(), first.registrationId());
CourseRegistrationResponse second = service.register(user.getId(), new CourseRegistrationRequest(lessonA.getId()));
assertThat(second.registrationId()).isNotEqualTo(first.registrationId());
assertThat(userLessonRepository.findAll()).hasSize(2);
assertThat(userLessonRepository.findAll().stream().filter(it -> it.getCanceledAt() == null)).hasSize(1);
Scenario.given(data)
.when(current -> service.register(
current.student().getId(),
new CourseRegistrationRequest(current.lesson().getId())))
.then(second -> {
assertThat(second.registrationId()).isNotEqualTo(first.registrationId());
assertThat(registrations.findAll()).hasSize(2);
assertThat(registrations.countByLesson_IdAndCanceledAtIsNull(data.lesson().getId()))
.isEqualTo(1);
});
}
@Test
void otherUserCannotCancelRegistration() {
CourseRegistrationResponse first = service.register(user.getId(), new CourseRegistrationRequest(lessonA.getId()));
User other = userRepository.save(new User("other-user", "다른학생", 2L, UserRole.STUDENT));
@DisplayName("다른 사용자 취소 → REGISTRATION_FORBIDDEN")
void cannotCancelOthers() {
CourseRegistrationResponse registration = service.register(
data.student().getId(),
new CourseRegistrationRequest(data.lesson().getId()));
User other = fixture.user(DomainFixtures.studentNamed("다른학생", 2));
assertThatThrownBy(() -> service.cancel(other.getId(), first.registrationId()))
.isInstanceOfSatisfying(RegistrationException.class,
ex -> assertThat(ex.getErrorCode()).isEqualTo(RegistrationErrorCode.REGISTRATION_FORBIDDEN));
Scenario.given(other)
.whenRunning(user -> service.cancel(user.getId(), registration.registrationId()))
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.REGISTRATION_FORBIDDEN);
}
@Test
void cancelingAlreadyCanceledRegistrationIsRejected() {
CourseRegistrationResponse first = service.register(user.getId(), new CourseRegistrationRequest(lessonA.getId()));
service.cancel(user.getId(), first.registrationId());
@DisplayName("취소 재호출 → 멱등 성공")
void repeatedCancelIsIdempotent() {
CourseRegistrationResponse registration = service.register(
data.student().getId(),
new CourseRegistrationRequest(data.lesson().getId()));
service.cancel(data.student().getId(), registration.registrationId());
assertThatThrownBy(() -> service.cancel(user.getId(), first.registrationId()))
.isInstanceOfSatisfying(RegistrationException.class,
ex -> assertThat(ex.getErrorCode()).isEqualTo(RegistrationErrorCode.ALREADY_CANCELED));
Scenario.given(data)
.whenRunning(current -> service.cancel(
current.student().getId(),
registration.registrationId()))
.then(ignored -> assertThat(
registrations.countByLesson_IdAndCanceledAtIsNull(data.lesson().getId()))
.isZero());
}
@Test
void cancelingFreesCapacityForNextRegistration() {
Lesson capacityOne = lessonRepository.save(new Lesson("capacity-one", "정원1", subjectB, professor, semester, 1, null, null));
lessonScheduleRepository.save(new LessonSchedule("capacity-one-schedule", capacityOne, DayOfWeek.WEDNESDAY, LocalTime.of(13, 0), LocalTime.of(15, 0)));
User other = userRepository.save(new User("capacity-other", "다른학생", 2L, UserRole.STUDENT));
@DisplayName("취소 건 → 신청 목록 제외")
void canceledRegistrationIsHidden() {
CourseRegistrationResponse registration = service.register(
data.student().getId(),
new CourseRegistrationRequest(data.lesson().getId()));
service.cancel(data.student().getId(), registration.registrationId());
CourseRegistrationResponse first = service.register(user.getId(), new CourseRegistrationRequest(capacityOne.getId()));
service.cancel(user.getId(), first.registrationId());
CourseRegistrationResponse second = service.register(other.getId(), new CourseRegistrationRequest(capacityOne.getId()));
assertThat(second.userId()).isEqualTo(other.getId());
assertThat(userLessonRepository.countByLesson_IdAndCanceledAtIsNull(capacityOne.getId())).isEqualTo(1);
Scenario.given(data)
.when(current -> service.getRegistrations(
current.student().getId(),
current.semester().getId()))
.then(result -> {
assertThat(result.totalCredits()).isZero();
assertThat(result.registrations()).isEmpty();
});
}
@Test
void cancellationOutsideRegistrationPeriodIsRejected() {
CourseRegistrationResponse registration = service.register(user.getId(), new CourseRegistrationRequest(lessonA.getId()));
Semester closedSemester = semesterRepository.save(new Semester("closed-semester", "closed", LocalDate.now().minusDays(100),
LocalDate.now().plusDays(100), Instant.now().minusSeconds(7200), Instant.now().minusSeconds(3600), 18));
Lesson closedLesson = lessonRepository.save(new Lesson("closed-lesson", "마감강의", subjectB, professor, closedSemester, 30, null, null));
lessonScheduleRepository.save(new LessonSchedule("closed-schedule", closedLesson, DayOfWeek.THURSDAY, LocalTime.of(9, 0), LocalTime.of(11, 0)));
var closedRegistration = userLessonRepository.saveAndFlush(new com.study.course_registration.entity.UserLesson(user, closedLesson));
@DisplayName("취소 후 정원 → 다음 사용자 신청 가능")
void cancelFreesCapacity() {
Subject subject = fixture.subject(DomainFixtures.subject("CAP"));
Lesson capacityOne = fixture.lesson(
DomainFixtures.lesson(subject, data.professor(), data.semester(), 1));
fixture.schedule(DomainFixtures.schedule(capacityOne, DayOfWeek.WEDNESDAY, 13, 15));
User other = fixture.user(DomainFixtures.studentNamed("대기학생", 2));
assertThatThrownBy(() -> service.cancel(user.getId(), closedRegistration.getId()))
.isInstanceOfSatisfying(RegistrationException.class,
ex -> assertThat(ex.getErrorCode()).isEqualTo(RegistrationErrorCode.REGISTRATION_PERIOD_CLOSED));
CourseRegistrationResponse first = service.register(
data.student().getId(),
new CourseRegistrationRequest(capacityOne.getId()));
service.cancel(data.student().getId(), first.registrationId());
assertThat(userLessonRepository.findById(registration.registrationId())).isPresent();
Scenario.given(other)
.when(user -> service.register(
user.getId(),
new CourseRegistrationRequest(capacityOne.getId())))
.thenAccepted();
}
@Test
void activeRegistrationListOmitsCanceledRows() {
CourseRegistrationResponse first = service.register(user.getId(), new CourseRegistrationRequest(lessonA.getId()));
service.cancel(user.getId(), first.registrationId());
service.register(user.getId(), new CourseRegistrationRequest(lessonB.getId()));
@DisplayName("다른 학기 신청 → 현재 학기 학점 계산 제외")
void creditsAreScopedBySemester() {
Semester otherSemester = fixture.semester(DomainFixtures.semester(
null,
"2027-1",
TestData.TODAY.plusDays(120),
TestData.TODAY.plusDays(240),
-3600,
3600,
18));
Subject otherSubject = fixture.subject(DomainFixtures.subject("OLD"));
Lesson otherLesson = fixture.lesson(
DomainFixtures.lesson(otherSubject, data.professor(), otherSemester));
fixture.schedule(DomainFixtures.schedule(otherLesson, DayOfWeek.FRIDAY, 9, 11));
fixture.registration(DomainFixtures.registration(data.student(), otherLesson));
var response = service.getRegistrations(user.getId(), semester.getId());
Scenario.given(data)
.when(current -> service.register(
current.student().getId(),
new CourseRegistrationRequest(current.lesson().getId())))
.then(response -> assertThat(response.totalCredits()).isEqualTo(3));
}
assertThat(response.totalCredits()).isEqualTo(3);
assertThat(response.registrations()).extracting(it -> it.lessonId()).containsExactly(lessonB.getId());
@Test
@DisplayName("신청 기간 종료 → REGISTRATION_PERIOD_CLOSED")
void closedPeriod() {
fixture.reset();
Semester closed = fixture.semester(DomainFixtures.closedSemester());
Professor professor = fixture.professor(DomainFixtures.professor());
Subject subject = fixture.subject(DomainFixtures.subject("CLOSED"));
User student = fixture.user(DomainFixtures.student(2));
Lesson lesson = fixture.lesson(DomainFixtures.lesson(subject, professor, closed));
fixture.schedule(DomainFixtures.schedule(lesson, DayOfWeek.MONDAY, 9, 11));
Scenario.given(student)
.when(user -> service.register(
user.getId(),
new CourseRegistrationRequest(lesson.getId())))
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.REGISTRATION_PERIOD_CLOSED);
}
@Test
@DisplayName("유효 신청 조회 → DTO 전체 매핑")
void activeRegistrationList() {
service.register(data.student().getId(), new CourseRegistrationRequest(data.lesson().getId()));
Scenario.given(data)
.when(current -> service.getRegistrations(
current.student().getId(),
current.semester().getId()))
.then(result -> {
assertThat(result.totalCredits()).isEqualTo(3);
assertThat(result.registrations()).singleElement().satisfies(item -> {
assertThat(item.lessonId()).isEqualTo(data.lesson().getId());
assertThat(item.subjectCode()).isEqualTo(data.subject().getCode());
assertThat(item.subjectName()).isEqualTo(data.subject().getName());
assertThat(item.credit()).isEqualTo(3);
assertThat(item.professorName()).isEqualTo(data.professor().getName());
assertThat(item.schedules()).hasSize(1);
assertThat(item.registeredAt()).isEqualTo(TestData.NOW);
});
});
}
@Test
@DisplayName("없는 사용자 신청 조회 → USER_NOT_FOUND")
void registrationListUserNotFound() {
Scenario.given("missing")
.when(userId -> service.getRegistrations(userId, data.semester().getId()))
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.USER_NOT_FOUND);
}
@Test
@DisplayName("없는 학기 신청 조회 → SEMESTER_NOT_FOUND")
void registrationListExplicitSemesterNotFound() {
Scenario.given("missing")
.when(semesterId -> service.getRegistrations(data.student().getId(), semesterId))
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.SEMESTER_NOT_FOUND);
}
@Test
@DisplayName("신청 기간 없음 + 학기 진행 중 → 학기 날짜 fallback")
void registrationListAcademicFallback() {
fixture.reset();
Semester academic = fixture.semester(DomainFixtures.academicSemester("academic"));
User student = fixture.user(DomainFixtures.student(2));
Scenario.given(student)
.when(user -> service.getRegistrations(user.getId(), null))
.then(result -> {
assertThat(result.semesterId()).isEqualTo(academic.getId());
assertThat(result.registrations()).isEmpty();
});
}
@Test
@DisplayName("현재 학기 없음 → SEMESTER_NOT_FOUND")
void registrationListSemesterNotFound() {
fixture.reset();
User student = fixture.user(DomainFixtures.student(2));
Scenario.given(student)
.when(user -> service.getRegistrations(user.getId(), null))
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.SEMESTER_NOT_FOUND);
}
@Test
@DisplayName("Idempotency-Key 101자 → VALIDATION_ERROR")
void idempotencyKeyTooLong() {
String key = "x".repeat(101);
Scenario.given(key)
.when(value -> service.register(
data.student().getId(),
new CourseRegistrationRequest(data.lesson().getId()),
value))
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.VALIDATION_ERROR);
}
}
@@ -1,96 +1,200 @@
package com.study.course_registration.service;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalTime;
import org.hibernate.SessionFactory;
import org.hibernate.stat.Statistics;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import com.study.course_registration.dto.lesson.LessonDetailResponse;
import com.study.course_registration.dto.lesson.LessonListResponse;
import com.study.course_registration.dto.registration.CourseRegistrationRequest;
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.entity.User;
import com.study.course_registration.enums.RegistrationErrorCode;
import com.study.course_registration.enums.UserRole;
import com.study.course_registration.exception.RegistrationException;
import com.study.course_registration.repository.*;
import com.study.course_registration.support.PostgresIntegrationTest;
import com.study.course_registration.support.Rejections;
import com.study.course_registration.support.Scenario;
import com.study.course_registration.support.fixture.DatabaseFixture;
import com.study.course_registration.support.fixture.DatabaseFixture.RegistrationDataset;
import com.study.course_registration.support.fixture.DomainFixtures;
@SpringBootTest
@ActiveProfiles("test")
class LessonQueryServiceIntegrationTest {
@Autowired LessonQueryService lessonQueryService;
import jakarta.persistence.EntityManagerFactory;
class LessonQueryServiceIntegrationTest extends PostgresIntegrationTest {
private static final Rejections<RegistrationException, RegistrationErrorCode> REJECTIONS =
Rejections.of(RegistrationException.class, RegistrationException::getErrorCode);
@Autowired LessonQueryService service;
@Autowired CourseRegistrationService registrationService;
@Autowired UserLessonRepository userLessonRepository;
@Autowired LessonScheduleRepository lessonScheduleRepository;
@Autowired LessonRepository lessonRepository;
@Autowired SubjectRepository subjectRepository;
@Autowired ProfessorRepository professorRepository;
@Autowired SemesterRepository semesterRepository;
@Autowired UserRepository userRepository;
@Autowired DatabaseFixture fixture;
@Autowired EntityManagerFactory entityManagerFactory;
private Semester semester;
private Lesson lesson;
private User user;
private RegistrationDataset data;
@BeforeEach
void setUp() {
userLessonRepository.deleteAll();
lessonScheduleRepository.deleteAll();
lessonRepository.deleteAll();
subjectRepository.deleteAll();
professorRepository.deleteAll();
semesterRepository.deleteAll();
userRepository.deleteAll();
Instant now = Instant.now();
semester = semesterRepository.save(new Semester("semester-query", "2026-1", LocalDate.now().minusDays(1),
LocalDate.now().plusDays(100), now.minusSeconds(3600), now.plusSeconds(3600), 18));
Professor professor = professorRepository.save(new Professor("prof-query", "조회교수"));
Subject subject = subjectRepository.save(new Subject("subject-query", "자료구조", "CS202", "자료구조 설명", 3));
lesson = lessonRepository.save(new Lesson("lesson-query", "자료구조 01", subject, professor, semester, 30, null, null));
lessonScheduleRepository.save(new LessonSchedule("schedule-query", lesson, DayOfWeek.MONDAY,
LocalTime.of(9, 0), LocalTime.of(11, 0)));
user = userRepository.save(new User("user-query", "조회학생", 2L, UserRole.STUDENT));
registrationService.register(user.getId(), new CourseRegistrationRequest(lesson.getId()));
data = fixture.registrationDataset();
registrationService.register(
data.student().getId(),
new CourseRegistrationRequest(data.lesson().getId()));
}
@Test
void listUsesCurrentSemesterAndReturnsBulkDerivedFields() {
var response = lessonQueryService.getLessons(null, null, 0, 20);
assertThat(response.totalElements()).isEqualTo(1);
assertThat(response.lessons()).singleElement().satisfies(item -> {
assertThat(item.lessonId()).isEqualTo(lesson.getId());
assertThat(item.enrolledCount()).isEqualTo(1);
assertThat(item.schedules()).hasSize(1);
});
@DisplayName("강의 목록 → 시간표·신청 수 포함")
void list() {
Scenario.given(data)
.when(current -> service.getLessons(current.semester().getId(), null, 0, 20))
.then(response -> {
assertThat(response.totalElements()).isEqualTo(1);
assertThat(response.lessons()).singleElement().satisfies(item -> {
assertThat(item.lessonId()).isEqualTo(data.lesson().getId());
assertThat(item.enrolledCount()).isEqualTo(1);
assertThat(item.schedules()).hasSize(1);
});
});
}
@Test
void detailContainsSubjectAndSemesterRegistrationMetadata() {
var response = lessonQueryService.getLesson(lesson.getId());
assertThat(response.subjectDescription()).isEqualTo("자료구조 설명");
assertThat(response.semesterName()).isEqualTo(semester.getName());
assertThat(response.enrolledCount()).isEqualTo(1);
assertThat(response.registrationStartAt().toEpochMilli()).isEqualTo(semester.getRegistrationStartAt().toEpochMilli());
@DisplayName("강의 상세 → 과목·학기·신청 수 포함")
void detail() {
Scenario.given(data.lesson().getId())
.when(service::getLesson)
.then(response -> {
assertThat(response.subjectDescription()).isEqualTo(data.subject().getDescription());
assertThat(response.semesterName()).isEqualTo(data.semester().getName());
assertThat(response.enrolledCount()).isEqualTo(1);
});
}
@Test
void unknownSemesterIsRejected() {
assertThatThrownBy(() -> lessonQueryService.getLessons("missing", null, 0, 20))
.isInstanceOfSatisfying(RegistrationException.class,
ex -> assertThat(ex.getErrorCode()).isEqualTo(RegistrationErrorCode.SEMESTER_NOT_FOUND));
@DisplayName("없는 학기 → SEMESTER_NOT_FOUND")
void unknownSemester() {
Scenario.given("missing")
.when(id -> service.getLessons(id, null, 0, 20))
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.SEMESTER_NOT_FOUND);
}
@Test
@DisplayName("subjectId 필터 → 해당 과목만 조회")
void subjectFilter() {
Subject other = fixture.subject(DomainFixtures.subject("CS999"));
Lesson otherLesson = fixture.lesson(DomainFixtures.lesson(other, data.professor(), data.semester()));
fixture.schedule(DomainFixtures.schedule(otherLesson, DayOfWeek.TUESDAY, 9, 11));
Scenario.given(other.getId())
.when(subjectId -> service.getLessons(data.semester().getId(), subjectId, 0, 20))
.then(response -> assertThat(response.lessons())
.extracting(item -> item.subjectCode())
.containsExactly("CS999"));
}
@Test
@DisplayName("페이지 크기 1 → 각 페이지 1건")
void pagination() {
Subject other = fixture.subject(DomainFixtures.subject("CS200"));
Lesson otherLesson = fixture.lesson(DomainFixtures.lesson(other, data.professor(), data.semester()));
fixture.schedule(DomainFixtures.schedule(otherLesson, DayOfWeek.TUESDAY, 9, 11));
LessonListResponse first = service.getLessons(data.semester().getId(), null, 0, 1);
Scenario.given(first)
.when(previous -> new PagePair(
previous,
service.getLessons(data.semester().getId(), null, 1, 1)))
.then(pair -> {
assertThat(pair.first().lessons()).hasSize(1);
assertThat(pair.second().lessons()).hasSize(1);
assertThat(pair.first().lessons().getFirst().lessonId())
.isNotEqualTo(pair.second().lessons().getFirst().lessonId());
});
}
@Test
@DisplayName("학기 시작 전 신청 기간 → 해당 학기 자동 선택")
void registrationWindowWinsOverAcademicDate() {
fixture.reset();
Semester future = fixture.semester(DomainFixtures.futureAcademicSemesterWithOpenRegistration());
Professor professor = fixture.professor(DomainFixtures.professor());
Subject subject = fixture.subject(DomainFixtures.subject("FUTURE"));
Lesson lesson = fixture.lesson(DomainFixtures.lesson(subject, professor, future));
fixture.schedule(DomainFixtures.schedule(lesson, DayOfWeek.MONDAY, 9, 11));
Scenario.given(lesson)
.when(ignored -> service.getLessons(null, null, 0, 20))
.then(response -> assertThat(response.lessons())
.extracting(item -> item.lessonId())
.containsExactly(lesson.getId()));
}
@Test
@DisplayName("강의 6건 조회 → SQL 6회 이하")
void bulkQueriesStayBounded() {
for (int index = 0; index < 5; index++) {
Subject subject = fixture.subject(DomainFixtures.subject("Q" + index));
Lesson lesson = fixture.lesson(DomainFixtures.lesson(subject, data.professor(), data.semester()));
fixture.schedule(DomainFixtures.schedule(lesson, DayOfWeek.of(index + 1), 13, 15));
}
Statistics statistics = entityManagerFactory.unwrap(SessionFactory.class).getStatistics();
statistics.clear();
Scenario.given(data)
.when(current -> service.getLessons(current.semester().getId(), null, 0, 20))
.then(response -> {
assertThat(response.lessons()).hasSize(6);
assertThat(statistics.getPrepareStatementCount()).isLessThanOrEqualTo(6);
});
}
@Test
@DisplayName("빈 학기 조회 → 빈 페이지")
void emptyPage() {
fixture.reset();
Semester semester = fixture.semester(DomainFixtures.openSemester());
Scenario.given(semester.getId())
.when(id -> service.getLessons(id, null, 0, 20))
.then(result -> {
assertThat(result.totalElements()).isZero();
assertThat(result.lessons()).isEmpty();
});
}
@Test
@DisplayName("신청 기간 없음 + 학기 진행 중 → 학기 날짜 fallback")
void academicFallback() {
fixture.reset();
Semester academic = fixture.semester(DomainFixtures.academicSemester("academic"));
Professor professor = fixture.professor(DomainFixtures.professor());
Subject subject = fixture.subject(DomainFixtures.subject("ACADEMIC"));
Lesson lesson = fixture.lesson(DomainFixtures.lesson(subject, professor, academic));
fixture.schedule(DomainFixtures.schedule(lesson, DayOfWeek.MONDAY, 9, 11));
Scenario.given(lesson)
.when(ignored -> service.getLessons(null, null, 0, 20))
.then(result -> assertThat(result.lessons())
.extracting(item -> item.lessonId())
.containsExactly(lesson.getId()));
}
@Test
@DisplayName("현재 학기 없음 → SEMESTER_NOT_FOUND")
void currentSemesterNotFound() {
fixture.reset();
Scenario.given(service)
.when(value -> value.getLessons(null, null, 0, 20))
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.SEMESTER_NOT_FOUND);
}
private record PagePair(LessonListResponse first, LessonListResponse second) {
}
}
@@ -0,0 +1,69 @@
package com.study.course_registration.service;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import com.study.course_registration.entity.Semester;
import com.study.course_registration.enums.RegistrationErrorCode;
import com.study.course_registration.exception.RegistrationException;
import com.study.course_registration.support.PostgresIntegrationTest;
import com.study.course_registration.support.Rejections;
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 {
private static final Rejections<RegistrationException, RegistrationErrorCode> REJECTIONS =
Rejections.of(RegistrationException.class, RegistrationException::getErrorCode);
@Autowired DatabaseFixture fixture;
@Autowired SemesterResolver resolver;
@BeforeEach
void setUp() {
fixture.reset();
}
@Test
@DisplayName("semesterId 명시 → 해당 학기")
void explicitSemester() {
Semester semester = fixture.semester(DomainFixtures.openSemester());
Scenario.given(semester.getId())
.when(resolver::resolve)
.then(result -> assertThat(result.getId()).isEqualTo(semester.getId()));
}
@Test
@DisplayName("신청 기간 학기 1개 → 해당 학기")
void registrationWindow() {
Semester semester = fixture.semester(DomainFixtures.futureAcademicSemesterWithOpenRegistration());
Scenario.given((String) null)
.when(resolver::resolve)
.then(result -> assertThat(result.getId()).isEqualTo(semester.getId()));
}
@Test
@DisplayName("신청 기간 학기 2개 → 데이터 오류")
void overlappingRegistrationWindows() {
fixture.semester(DomainFixtures.openSemester("semester-a", "A", 18));
fixture.semester(DomainFixtures.openSemester("semester-b", "B", 18));
assertThatThrownBy(() -> resolver.resolve(null))
.isInstanceOf(IllegalStateException.class)
.hasMessageContaining("두 개 이상의 수강신청 학기");
}
@Test
@DisplayName("활성 학기 없음 → SEMESTER_NOT_FOUND")
void notFound() {
Scenario.given((String) null)
.when(resolver::resolve)
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.SEMESTER_NOT_FOUND);
}
}
@@ -0,0 +1,39 @@
package com.study.course_registration.service.lock;
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.when;
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.entity.Lesson;
import com.study.course_registration.entity.User;
import com.study.course_registration.repository.LessonRepository;
import com.study.course_registration.repository.UserRepository;
import com.study.course_registration.support.fixture.DomainFixtures;
class RegistrationLockManagerTest {
@Test
@DisplayName("락 획득 순서 → User 다음 Lesson")
void userThenLesson() {
UserRepository users = mock(UserRepository.class);
LessonRepository lessons = mock(LessonRepository.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));
RegistrationLockManager.LockedRegistration result = new RegistrationLockManager(users, lessons).lock("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);
}
}
@@ -0,0 +1,69 @@
package com.study.course_registration.service.policy;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
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.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 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));
assertThatThrownBy(() -> policy.validate(schedules))
.isInstanceOf(IllegalArgumentException.class);
}
@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();
}
}
@@ -13,185 +13,106 @@ 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.enums.UserRole;
import com.study.course_registration.support.fixture.DomainFixtures;
import com.study.course_registration.support.fixture.TestData;
/**
* 수강신청 도메인의 given 조립 + when 행동. 도메인 지식은 전부 여기 모인다.
*
* <p>given/when/then의 <em>틀</em>은 {@link com.study.course_registration.support.Scenario}가 들고 있고,
* 이 클래스는 그 틀에 넣을 <em>내용</em>만 안다. 도메인이 늘어나면 이 파일이 아니라
* 새 도메인용 Fixture가 하나 더 생긴다.
*
* <p>R1~R8 테스트는 전부 "어떤 학생이 / 어떤 학기에 / 이미 무엇을 신청한 상태로 / 무엇을 신청한다"는
* 같은 뼈대를 쓴다. 규칙마다 그중 한두 칸만 달라지므로, 뼈대는 여기에 두고 테스트에는 달라지는 칸만 적는다.
*
* <p>when 단계는 {@link #checkEligibility()} / {@link #register()} 두 개다.
* 예외를 잡는 일은 {@code Scenario.when(...)}이 하므로 여기서는 그냥 던진다.
*/
final class RegistrationFixture {
private static final String CANDIDATE_LESSON_ID = "lesson-b";
private static final String EXISTING_LESSON_ID = "lesson-a";
private final RegistrationValidator validator = new RegistrationValidator(new ScheduleConflictChecker());
private Semester semester = TestFixtures.semester(18);
private Semester semester = DomainFixtures.openSemester("semester-1", "2026-1", 18);
private final long grade;
private String candidateSubjectId = "subject-b";
private int candidateCredit = 3;
private int capacity = 30;
private Long minGrade;
private UserRole allowedRole;
private Slot candidateSlot;
private Slot candidateSlot = new Slot(DayOfWeek.MONDAY, 15, 16);
private boolean existingIsSameLesson;
private String existingSubjectId;
private int existingCredit = 3;
private Slot existingSlot;
private Slot existingSlot = new Slot(DayOfWeek.TUESDAY, 15, 16);
private long enrolledCount = 1;
private RegistrationFixture(long grade) {
this.grade = grade;
}
private RegistrationFixture(long grade) { this.grade = grade; }
/** given: N학년 학부생. 모든 시나리오의 시작점이다. */
static RegistrationFixture student(long grade) {
return new RegistrationFixture(grade);
}
static RegistrationFixture student(long grade) { return new RegistrationFixture(grade); }
RegistrationFixture semesterWithMaxCredits(int maxCredits) { semester = DomainFixtures.openSemester("semester-1", "2026-1", maxCredits); return this; }
RegistrationFixture inClosedSemester() { semester = DomainFixtures.closedSemester("semester-closed", "closed"); return this; }
RegistrationFixture applyingFor(String subjectId, int credit) { candidateSubjectId = subjectId; candidateCredit = credit; return this; }
RegistrationFixture requiringMinGrade(long value) { minGrade = value; return this; }
RegistrationFixture requiringRole(UserRole role) { allowedRole = role; return this; }
RegistrationFixture withCapacity(int value) { capacity = value; return this; }
RegistrationFixture alreadyEnrolled(long value) { enrolledCount = value; return this; }
RegistrationFixture scheduledOn(DayOfWeek day, int start, int end) { candidateSlot = new Slot(day, start, end); return this; }
RegistrationFixture withoutSchedule() { candidateSlot = null; return this; }
RegistrationFixture alreadyRegisteredSameLesson() { existingIsSameLesson = true; return this; }
RegistrationFixture alreadyRegistered(String subjectId, int credit) { existingSubjectId = subjectId; existingCredit = credit; return this; }
RegistrationFixture alreadyRegisteredOn(DayOfWeek day, int start, int end) { existingSlot = new Slot(day, start, end); return this; }
RegistrationFixture existingWithoutSchedule() { existingSlot = null; return this; }
/** given: 학점 상한이 N인 학기 (기본 18) */
RegistrationFixture semesterWithMaxCredits(int maxCredits) {
this.semester = TestFixtures.semester(maxCredits);
return this;
}
RegistrationFixture checkEligibility() { return checkEligibilityAt(TestData.NOW); }
/** given: 신청 기간이 이미 끝난 학기 */
RegistrationFixture inClosedSemester() {
this.semester = TestFixtures.closedSemester();
return this;
}
/** given: 신청하려는 강의의 과목과 학점 (기본 subject-b / 3학점) */
RegistrationFixture applyingFor(String subjectId, int credit) {
this.candidateSubjectId = subjectId;
this.candidateCredit = credit;
return this;
}
/** given: 신청하려는 강의에 걸린 최소 학년 제한 */
RegistrationFixture requiringMinGrade(long minGrade) {
this.minGrade = minGrade;
return this;
}
/** given: 신청하려는 강의에 걸린 역할 제한 */
RegistrationFixture requiringRole(UserRole role) {
this.allowedRole = role;
return this;
}
/** given: 신청하려는 강의의 정원 (기본 30) */
RegistrationFixture withCapacity(int capacity) {
this.capacity = capacity;
return this;
}
/** given: 신청하려는 강의의 현재 유효 신청 수 (기본 1) */
RegistrationFixture alreadyEnrolled(long enrolledCount) {
this.enrolledCount = enrolledCount;
return this;
}
/** given: 신청하려는 강의의 수업 시간 */
RegistrationFixture scheduledOn(DayOfWeek day, int startHour, int endHour) {
this.candidateSlot = new Slot(day, startHour, endHour);
return this;
}
/** given: 지금 신청하려는 바로 그 강의를 이미 신청해 둔 상태 (R4) */
RegistrationFixture alreadyRegisteredSameLesson() {
this.existingIsSameLesson = true;
return this;
}
/** given: 다른 강의를 이미 신청해 둔 상태. 과목 코드가 같으면 같은 과목의 다른 분반이 된다 (R5) */
RegistrationFixture alreadyRegistered(String subjectId, int credit) {
this.existingSubjectId = subjectId;
this.existingCredit = credit;
return this;
}
/** given: 이미 신청해 둔 강의의 수업 시간 */
RegistrationFixture alreadyRegisteredOn(DayOfWeek day, int startHour, int endHour) {
this.existingSlot = new Slot(day, startHour, endHour);
return this;
}
/** when: 신청 기간·학년·역할만 보는 사전 검사 (R1~R3). 값이 없는 행동이라 자기 자신을 돌려준다. */
RegistrationFixture checkEligibility() {
return checkEligibilityAt(TestFixtures.NOW);
}
/** when: 특정 시각 기준으로 사전 검사 */
RegistrationFixture checkEligibilityAt(Instant now) {
Fixture fixture = assemble();
validator.validatePreconditions(fixture.user(), fixture.candidate(), now);
return this;
}
/** when: 락을 잡은 뒤의 본 검사 — 중복·시간표·학점·정원 (R4~R8) */
RegistrationFixture register() {
Fixture fixture = assemble();
validator.validateLocked(
fixture.candidate(), fixture.existingRegistrations(), fixture.schedules(), enrolledCount);
validator.validateLocked(fixture.candidate(), fixture.existingRegistrations(), fixture.schedules(), enrolledCount);
return this;
}
RegistrationFixture attempt() {
checkEligibility();
register();
return this;
}
/** 신청이 성사됐을 때의 누적 학점 */
int totalCreditsAfter() {
Fixture fixture = assemble();
return validator.totalCreditsAfter(fixture.candidate(), fixture.existingRegistrations());
}
Instant registrationEndAt() {
return semester.getRegistrationEndAt();
}
Instant registrationStartAt() { return semester.getRegistrationStartAt(); }
Instant registrationEndAt() { return semester.getRegistrationEndAt(); }
private Fixture assemble() {
User user = TestFixtures.student("user", grade);
Lesson candidate = TestFixtures.lesson(CANDIDATE_LESSON_ID,
TestFixtures.subject(candidateSubjectId, candidateCredit), semester, capacity, minGrade, allowedRole);
List<UserLesson> existingRegistrations = new ArrayList<>();
User user = DomainFixtures.student("user", grade);
Lesson candidate = DomainFixtures.lesson(CANDIDATE_LESSON_ID, CANDIDATE_LESSON_ID,
DomainFixtures.subject(candidateSubjectId, candidateSubjectId, candidateCredit),
DomainFixtures.professor("prof-" + CANDIDATE_LESSON_ID),
semester, 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) {
existingRegistrations.add(TestFixtures.registration("reg", user, candidate));
existing.add(DomainFixtures.registration("reg", user, candidate));
} else if (existingSubjectId != null) {
Lesson existingLesson = TestFixtures.lesson(EXISTING_LESSON_ID,
TestFixtures.subject(existingSubjectId, existingCredit), semester, 30, null, null);
existingRegistrations.add(TestFixtures.registration("reg", user, existingLesson));
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, existingRegistrations, schedules);
return new Fixture(user, candidate, existing, schedules);
}
private record Slot(DayOfWeek day, int startHour, int endHour) {
LessonSchedule toSchedule(String id, Lesson lesson) {
return TestFixtures.schedule(id, lesson, day, startHour, endHour);
return DomainFixtures.schedule(id, lesson, day, startHour, endHour);
}
}
private record Fixture(User user,
Lesson candidate,
List<UserLesson> existingRegistrations,
Map<String, List<LessonSchedule>> schedules) {
}
private record Fixture(User user, Lesson candidate, List<UserLesson> existingRegistrations,
Map<String, List<LessonSchedule>> schedules) {}
}
@@ -16,155 +16,169 @@ import com.study.course_registration.exception.RegistrationException;
import com.study.course_registration.support.Rejections;
import com.study.course_registration.support.Scenario;
/**
* given → when → then 세 단계를 전부 {@link Scenario}에 맡긴다.
*
* <p>이 파일에서 도메인에 묶인 것은 아래 {@code REJECTIONS} 상수 한 줄과, given에 적는 조건뿐이다.
* 나머지 흐름은 어떤 도메인 테스트에서도 같은 모양이다.
*/
@DisplayName("수강신청 거부 규칙 R1~R8 (Requirements.md 4.1)")
@DisplayName("수강신청 정책")
class RegistrationValidatorTest {
/** 이 도메인이 거부하는 방식. then이 도메인을 아는 지점은 여기 한 곳뿐이다. */
private static final Rejections<RegistrationException, RegistrationErrorCode> REJECTIONS =
Rejections.of(RegistrationException.class, RegistrationException::getErrorCode);
@Nested
@DisplayName("R1 신청 기간 — 기간 밖이면 REGISTRATION_PERIOD_CLOSED")
class RegistrationPeriod {
@DisplayName("R1 신청 기간")
class Period {
@Test
@DisplayName("신청 종료 시각 정각에 신청하면 통과한다 (종료 시각은 기간에 포함된다)")
void endAtIsInclusive() {
RegistrationFixture fixture = RegistrationFixture.student(1);
Scenario.given(fixture)
.when(f -> f.checkEligibilityAt(fixture.registrationEndAt()))
.thenAccepted();
@DisplayName("시작 정각 → 허용")
void startInclusive() {
RegistrationFixture fixture = RegistrationFixture.student(2);
Scenario.given(fixture).when(f -> f.checkEligibilityAt(f.registrationStartAt())).thenAccepted();
}
@Test
@DisplayName("기간이 지났으면 학년·역할 조건도 함께 어겨도 기간 오류를 먼저 반환한다")
void closedPeriodIsCheckedBeforeEligibility() {
Scenario.given(RegistrationFixture.student(1)
.inClosedSemester()
.requiringMinGrade(3)
.requiringRole(UserRole.POSTGRADUATE))
.when(RegistrationFixture::checkEligibility)
@DisplayName("종료 정각 → 허용")
void endInclusive() {
RegistrationFixture fixture = RegistrationFixture.student(2);
Scenario.given(fixture).when(f -> f.checkEligibilityAt(f.registrationEndAt())).thenAccepted();
}
@Test
@DisplayName("기간 종료 + 학년 미달 → R1")
void periodBeforeGrade() {
Scenario.given(RegistrationFixture.student(1).inClosedSemester().requiringMinGrade(3))
.when(RegistrationFixture::attempt)
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.REGISTRATION_PERIOD_CLOSED);
}
}
@Nested
@DisplayName("R2 학년 제한 — 미달이면 NOT_ELIGIBLE_GRADE")
class MinGrade {
@DisplayName("R2~R5 자격·중복")
class EligibilityAndDuplicate {
@Test
@DisplayName("1학년이 3학년 이상 강의를 신청하면 거부한다")
void rejectsGradeBelowMinimum() {
Scenario.given(RegistrationFixture.student(1)
.requiringMinGrade(3))
.when(RegistrationFixture::checkEligibility)
@DisplayName("학년 미달 + 역할 불일치 → R2")
void gradeBeforeRole() {
Scenario.given(RegistrationFixture.student(1).requiringMinGrade(3).requiringRole(UserRole.POSTGRADUATE))
.when(RegistrationFixture::attempt)
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.NOT_ELIGIBLE_GRADE);
}
}
@Nested
@DisplayName("R3 역할 제한 — 불일치하면 NOT_ELIGIBLE_ROLE")
class AllowedRole {
@Test
@DisplayName("학부생이 대학원생 전용 강의를 신청하면 거부한다")
void rejectsRoleMismatch() {
Scenario.given(RegistrationFixture.student(3)
.requiringRole(UserRole.POSTGRADUATE))
.when(RegistrationFixture::checkEligibility)
@DisplayName("역할 불일치 + 같은 강의 → R3")
void roleBeforeDuplicate() {
Scenario.given(RegistrationFixture.student(3).requiringRole(UserRole.POSTGRADUATE).alreadyRegisteredSameLesson())
.when(RegistrationFixture::attempt)
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.NOT_ELIGIBLE_ROLE);
}
}
@Nested
@DisplayName("R4·R5 중복 신청 — 같은 분반이면 ALREADY_REGISTERED, 다른 분반이면 DUPLICATE_SUBJECT")
class Duplicate {
@Test
@DisplayName("이미 신청한 그 강의를 다시 신청하면 과목 중복보다 강의 중복을 먼저 반환한다")
void sameLessonTakesPrecedenceOverSameSubject() {
Scenario.given(RegistrationFixture.student(2)
.alreadyRegisteredSameLesson())
.when(RegistrationFixture::register)
@DisplayName("같은 강의 → R4")
void duplicateLesson() {
Scenario.given(RegistrationFixture.student(2).alreadyRegisteredSameLesson())
.when(RegistrationFixture::attempt)
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.ALREADY_REGISTERED);
}
@Test
@DisplayName("같은 과목의 다른 분반을 신청하면 거부한다")
void rejectsDifferentSectionOfSameSubject() {
@DisplayName("같은 과목 다른 분반 → R5")
void duplicateSubject() {
Scenario.given(RegistrationFixture.student(2).applyingFor("subject", 3).alreadyRegistered("subject", 3))
.when(RegistrationFixture::attempt)
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.DUPLICATE_SUBJECT);
}
@Test
@DisplayName("과목 중복 + 시간 충돌 → R5")
void duplicateSubjectBeforeSchedule() {
Scenario.given(RegistrationFixture.student(2)
.applyingFor("subject", 3)
.alreadyRegistered("subject", 3))
.when(RegistrationFixture::register)
.applyingFor("same", 3).scheduledOn(DayOfWeek.MONDAY, 10, 12)
.alreadyRegistered("same", 3).alreadyRegisteredOn(DayOfWeek.MONDAY, 9, 11))
.when(RegistrationFixture::attempt)
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.DUPLICATE_SUBJECT);
}
}
@Nested
@DisplayName("R6 시간표 충돌 — 겹치면 SCHEDULE_CONFLICT")
class ScheduleConflict {
@ParameterizedTest(name = "[{index}] {5}")
@DisplayName("R6 시간표")
class Schedule {
@ParameterizedTest(name = "{4}")
@CsvSource(textBlock = """
# 기존 수업 시작, 끝 | 신청 수업 시작, 끝 | 기대 에러(비우면 통과) | 설명
9, 11, 10, 12, SCHEDULE_CONFLICT, '기존 수업과 시간이 겹치면 거부한다 (월 9-11 vs 월 10-12)'
9, 11, 11, 13, , '앞 수업이 끝나는 시각에 시작하면 신청할 수 있다 (월 9-11 vs 월 11-13)'
9, 11, 10, 12, '겹침 → R6'
9, 11, 11, 13, '경계 접촉 → 허용'
""")
void scheduleOverlap(int existingStart, int existingEnd, int newStart, int newEnd,
RegistrationErrorCode expected, String description) {
Scenario.given(RegistrationFixture.student(2)
.alreadyRegistered("subject-a", 3)
.alreadyRegisteredOn(DayOfWeek.MONDAY, existingStart, existingEnd)
.applyingFor("subject-b", 3)
.scheduledOn(DayOfWeek.MONDAY, newStart, newEnd))
.when(RegistrationFixture::register)
.then(REJECTIONS, expected);
}
}
@Nested
@DisplayName("R7 학점 상한 — 초과하면 CREDIT_LIMIT_EXCEEDED")
class CreditLimit {
@ParameterizedTest(name = "[{index}] {4}")
@CsvSource(textBlock = """
# 학기 상한 | 기존 신청 학점 | 신청 강의 학점 | 기대 에러(비우면 통과) | 설명
6, 3, 3, , '합계가 상한과 정확히 같으면 신청할 수 있다 (3+3=6)'
5, 3, 3, CREDIT_LIMIT_EXCEEDED , '합계가 상한을 넘으면 거부한다 (3+3>5)'
""")
void creditLimit(int maxCredits, int existingCredit, int newCredit,
RegistrationErrorCode expected, String description) {
void overlap(int oldStart, int oldEnd, int newStart, int newEnd, String name) {
RegistrationFixture fixture = RegistrationFixture.student(2)
.semesterWithMaxCredits(maxCredits)
.alreadyRegistered("subject-a", existingCredit)
.applyingFor("subject-b", newCredit);
.alreadyRegistered("old", 3).alreadyRegisteredOn(DayOfWeek.MONDAY, oldStart, oldEnd)
.applyingFor("new", 3).scheduledOn(DayOfWeek.MONDAY, newStart, newEnd);
Scenario.given(fixture)
.when(RegistrationFixture::register)
.then(REJECTIONS, expected);
if (newStart < oldEnd) {
Scenario.given(fixture).when(RegistrationFixture::attempt)
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.SCHEDULE_CONFLICT);
} else {
Scenario.given(fixture).when(RegistrationFixture::attempt).thenAccepted();
}
}
assertThat(fixture.totalCreditsAfter())
.as("신청 후 누적 학점")
.isEqualTo(existingCredit + newCredit);
@Test
@DisplayName("시간 충돌 + 학점 초과 → R6")
void scheduleBeforeCredit() {
Scenario.given(RegistrationFixture.student(2).semesterWithMaxCredits(5)
.alreadyRegistered("old", 3).alreadyRegisteredOn(DayOfWeek.MONDAY, 9, 11)
.applyingFor("new", 3).scheduledOn(DayOfWeek.MONDAY, 10, 12))
.when(RegistrationFixture::attempt)
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.SCHEDULE_CONFLICT);
}
@Test
@DisplayName("신청 강의 시간표 없음 → 500")
void missingCandidateSchedule() {
Scenario.given(RegistrationFixture.student(2).withoutSchedule())
.when(RegistrationFixture::attempt)
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.INTERNAL_SERVER_ERROR);
}
@Test
@DisplayName("기존 강의 시간표 없음 → 500")
void missingExistingSchedule() {
Scenario.given(RegistrationFixture.student(2).alreadyRegistered("old", 3).existingWithoutSchedule())
.when(RegistrationFixture::attempt)
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.INTERNAL_SERVER_ERROR);
}
}
@Nested
@DisplayName("R8 정원 — 가득 차면 CAPACITY_EXCEEDED")
class Capacity {
@ParameterizedTest(name = "[{index}] {3}")
@DisplayName("R7 학점")
class Credit {
@ParameterizedTest(name = "{4}")
@CsvSource(textBlock = """
# 정원 | 현재 유효 신청 수 | 기대 에러(비우면 통과) | 설명
30, 29, , '마지막 한 자리는 신청할 수 있다 (29/30)'
30, 30, CAPACITY_EXCEEDED , '정원이 가득 차면 거부한다 (30/30)'
6, 3, 3, , '3+3=6 → 허용'
5, 3, 3, CREDIT_LIMIT_EXCEEDED, '3+3>5 → R7'
""")
void capacity(int capacity, long enrolledCount,
RegistrationErrorCode expected, String description) {
Scenario.given(RegistrationFixture.student(2)
.withCapacity(capacity)
.alreadyEnrolled(enrolledCount))
.when(RegistrationFixture::register)
void limit(int max, int oldCredit, int newCredit, RegistrationErrorCode expected, String name) {
RegistrationFixture fixture = RegistrationFixture.student(2).semesterWithMaxCredits(max)
.alreadyRegistered("old", oldCredit).applyingFor("new", newCredit);
Scenario.given(fixture).when(RegistrationFixture::attempt).then(REJECTIONS, expected);
assertThat(fixture.totalCreditsAfter()).isEqualTo(oldCredit + newCredit);
}
@Test
@DisplayName("학점 초과 + 정원 초과 → R7")
void creditBeforeCapacity() {
Scenario.given(RegistrationFixture.student(2).semesterWithMaxCredits(5)
.alreadyRegistered("old", 3).applyingFor("new", 3)
.withCapacity(30).alreadyEnrolled(30))
.when(RegistrationFixture::attempt)
.thenRejectedWith(REJECTIONS, RegistrationErrorCode.CREDIT_LIMIT_EXCEEDED);
}
}
@Nested
@DisplayName("R8 정원")
class Capacity {
@ParameterizedTest(name = "{3}")
@CsvSource(textBlock = """
30, 29, , '29/30 → 허용'
30, 30, CAPACITY_EXCEEDED, '30/30 → R8'
""")
void capacity(int capacity, long enrolled, RegistrationErrorCode expected, String name) {
Scenario.given(RegistrationFixture.student(2).withCapacity(capacity).alreadyEnrolled(enrolled))
.when(RegistrationFixture::attempt)
.then(REJECTIONS, expected);
}
}
@@ -9,29 +9,25 @@ import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import com.study.course_registration.entity.LessonSchedule;
import com.study.course_registration.support.fixture.DomainFixtures;
@DisplayName("R6 시간 블록 겹침 판정 (Requirements.md 4.3)")
@DisplayName("시간표 겹침")
class ScheduleConflictCheckerTest {
private final ScheduleConflictChecker checker = new ScheduleConflictChecker();
@DisplayName("두 시간 블록이 겹치는지 판정한다")
@ParameterizedTest(name = "[{index}] {7}")
@ParameterizedTest(name = "{7}")
@CsvSource(textBlock = """
# 블록A 요일, 시작, 끝 | 블록B 요일, 시작, 끝 | 겹치는가 | 설명
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, '시간이 같아도 요일이 다르면 충돌이 아니다'
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 description) {
// given
LessonSchedule a = TestFixtures.schedule(dayA, startA, endA);
LessonSchedule b = TestFixtures.schedule(dayB, startB, endB);
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);
// when & then
assertThat(checker.overlaps(a, b)).as(description).isEqualTo(expected);
assertThat(checker.overlaps(b, a)).as(description + " (순서를 바꿔도 같다)").isEqualTo(expected);
assertThat(checker.overlaps(a, b)).isEqualTo(expected);
assertThat(checker.overlaps(b, a)).isEqualTo(expected);
}
}
@@ -1,63 +0,0 @@
package com.study.course_registration.service.policy;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalTime;
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.entity.User;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.enums.UserRole;
final class TestFixtures {
static final Instant NOW = Instant.parse("2026-09-17T10:00:00Z");
private TestFixtures() {
}
static Semester semester(int maxCredits) {
return new Semester("semester-1", "2026-1", LocalDate.of(2026, 9, 1), LocalDate.of(2026, 12, 31),
NOW.minusSeconds(3600), NOW.plusSeconds(3600), maxCredits);
}
static Semester closedSemester() {
return new Semester("semester-closed", "closed", LocalDate.of(2026, 1, 1), LocalDate.of(2026, 2, 1),
NOW.minusSeconds(7200), NOW.minusSeconds(3600), 18);
}
static User student(String id, long grade) {
return new User(id, id, grade, UserRole.STUDENT);
}
static User postgraduate(String id) {
return new User(id, id, 3L, UserRole.POSTGRADUATE);
}
static Lesson lesson(String id, Subject subject, Semester semester, int capacity, Long minGrade, UserRole role) {
return new Lesson(id, id, subject, new Professor("prof-" + id, "prof"), semester, capacity, minGrade, role);
}
static Subject subject(String id, int credit) {
return new Subject(id, id, id, id, credit);
}
static UserLesson registration(String id, User user, Lesson lesson) {
return new UserLesson(id, user, lesson);
}
static LessonSchedule schedule(DayOfWeek day, int startHour, int endHour) {
Subject subject = subject("subject-" + day + startHour, 3);
Lesson lesson = lesson("lesson-" + day + startHour, subject, semester(18), 30, null, null);
return new LessonSchedule("schedule-" + day + startHour, lesson, day,
LocalTime.of(startHour, 0), LocalTime.of(endHour, 0));
}
static LessonSchedule schedule(String id, Lesson lesson, DayOfWeek day, int startHour, int endHour) {
return new LessonSchedule(id, lesson, day, LocalTime.of(startHour, 0), LocalTime.of(endHour, 0));
}
}
@@ -0,0 +1,22 @@
package com.study.course_registration.support;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.ActiveProfiles;
import com.study.course_registration.support.fixture.TestFixtureConfig;
@Inherited
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@SpringBootTest
@ActiveProfiles("test")
@Import(TestFixtureConfig.class)
public @interface CourseIntegrationTest {
}
@@ -2,13 +2,8 @@ package com.study.course_registration.support;
import static org.assertj.core.api.Assertions.assertThat;
/**
* then 단계. when의 실행 결과는 값을 돌려줬거나 예외로 거부됐거나 둘 중 하나다.
*
* <p>도메인 타입을 모른다. 예외 타입과 코드 추출 방식은 {@link Rejections}로 받는다.
*
* @param <R> when이 돌려준 값의 타입
*/
import java.util.function.Consumer;
public final class Outcome<R> {
private final R result;
private final RuntimeException thrown;
@@ -18,38 +13,34 @@ public final class Outcome<R> {
this.thrown = thrown;
}
/** then: 거부되지 않아야 한다. 돌려준 값을 그대로 넘겨주므로 이어서 내용을 확인할 수 있다. */
public R thenAccepted() {
if (thrown != null) {
throw new AssertionError("통과해야 하는데 " + thrown.getClass().getSimpleName()
+ " 이(가) 발생했다: " + thrown.getMessage(), thrown);
throw new AssertionError(
"성공해야 하지만 " + thrown.getClass().getSimpleName() + " 발생: " + thrown.getMessage(),
thrown);
}
return result;
}
/**
* then: {@code expected}가 null이면 통과, 값이 있으면 그 코드로 거부되어야 한다.
*
* <p>표 기반 테스트에서 "기대 에러 칸이 비어 있으면 통과"를 그대로 표현하기 위한 형태다.
*/
public void then(Consumer<R> assertions) {
assertions.accept(thenAccepted());
}
public void thenAccepted(Consumer<R> assertions) {
then(assertions);
}
public <X extends RuntimeException, E> void then(Rejections<X, E> rejections, E expected) {
if (expected == null) {
thenAccepted();
} else {
thenRejectedWith(rejections, expected);
return;
}
thenRejectedWith(rejections, expected);
}
/** then: 주어진 도메인의 예외로, 주어진 사유 코드로 거부되어야 한다. */
public <X extends RuntimeException, E> void thenRejectedWith(Rejections<X, E> rejections, E expected) {
assertThat(thrown)
.as("%s (으)로 거부되어야 하는데 통과했다", expected)
.isNotNull();
assertThat(thrown)
.as("거부 예외 타입")
.isInstanceOf(rejections.type());
assertThat(rejections.codeOf(thrown))
.as("거부 사유")
.isEqualTo(expected);
assertThat(thrown).as("예외가 발생해야 한다").isNotNull();
assertThat(thrown).isInstanceOf(rejections.type());
assertThat(rejections.codeOf(thrown)).isEqualTo(expected);
}
}
@@ -0,0 +1,63 @@
package com.study.course_registration.support;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.function.Supplier;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;
public final class PessimisticLockProbe {
private PessimisticLockProbe() {}
public static void assertSecondTransactionBlocks(
PlatformTransactionManager transactionManager,
Supplier<?> firstLock,
Supplier<?> secondLock) throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(2);
CountDownLatch firstLocked = new CountDownLatch(1);
CountDownLatch releaseFirst = new CountDownLatch(1);
TransactionTemplate transaction = new TransactionTemplate(transactionManager);
try {
Future<?> first = executor.submit(() -> transaction.executeWithoutResult(status -> {
firstLock.get();
firstLocked.countDown();
await(releaseFirst);
}));
assertThat(firstLocked.await(5, TimeUnit.SECONDS)).isTrue();
Future<?> second = executor.submit(() -> transaction.executeWithoutResult(status -> secondLock.get()));
assertThatThrownBy(() -> second.get(250, TimeUnit.MILLISECONDS))
.isInstanceOf(TimeoutException.class);
releaseFirst.countDown();
first.get(5, TimeUnit.SECONDS);
second.get(5, TimeUnit.SECONDS);
} finally {
releaseFirst.countDown();
executor.shutdownNow();
executor.awaitTermination(5, TimeUnit.SECONDS);
}
}
private static void await(CountDownLatch latch) {
try {
if (!latch.await(5, TimeUnit.SECONDS)) {
throw new AssertionError("락 테스트 release 신호를 받지 못했습니다.");
}
} catch (InterruptedException interrupted) {
Thread.currentThread().interrupt();
throw new AssertionError("락 테스트가 중단되었습니다.", interrupted);
}
}
}
@@ -0,0 +1,26 @@
package com.study.course_registration.support;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.postgresql.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Testcontainers;
import org.testcontainers.utility.DockerImageName;
@CourseIntegrationTest
@Testcontainers
public abstract class PostgresIntegrationTest {
private static final PostgreSQLContainer POSTGRES = new PostgreSQLContainer(DockerImageName.parse("postgres:16-alpine"));
static {
POSTGRES.start();
}
@DynamicPropertySource
static void postgres(DynamicPropertyRegistry registry) {
registry.add("spring.datasource.url", POSTGRES::getJdbcUrl);
registry.add("spring.datasource.username", POSTGRES::getUsername);
registry.add("spring.datasource.password", POSTGRES::getPassword);
registry.add("spring.flyway.locations", () -> "classpath:db/migration/postgresql");
registry.add("spring.datasource.hikari.connection-init-sql", () -> "SET lock_timeout TO '3s'");
}
}
@@ -2,20 +2,6 @@ package com.study.course_registration.support;
import java.util.function.Function;
/**
* "이 도메인은 어떤 예외로 거부하고, 그 예외에서 사유 코드를 어떻게 꺼내는가"를 담은 값.
*
* <p>then 단계가 도메인에 묶이는 이유는 이 두 가지뿐이다. 그래서 이것만 값으로 넘기면
* then도 제네릭이 된다. 새 도메인은 상수 한 줄만 선언하면 된다.
*
* <pre>{@code
* Rejections.of(RegistrationException.class, RegistrationException::getErrorCode);
* Rejections.of(PaymentException.class, PaymentException::getCode);
* }</pre>
*
* @param <X> 그 도메인이 거부할 때 던지는 예외
* @param <E> 거부 사유 코드 타입 (보통 enum)
*/
public final class Rejections<X extends RuntimeException, E> {
private final Class<X> type;
private final Function<X, E> codeOf;
@@ -29,11 +15,6 @@ public final class Rejections<X extends RuntimeException, E> {
return new Rejections<>(type, codeOf);
}
Class<X> type() {
return type;
}
E codeOf(Throwable thrown) {
return codeOf.apply(type.cast(thrown));
}
Class<X> type() { return type; }
E codeOf(Throwable thrown) { return codeOf.apply(type.cast(thrown)); }
}
@@ -1,24 +1,8 @@
package com.study.course_registration.support;
import java.util.function.Consumer;
import java.util.function.Function;
/**
* given → when 을 표현하는 도메인 무관·계층 무관 테스트 하네스.
*
* <p>어떤 도메인 타입도, 어떤 계층(단위/통합/HTTP)도 여기 등장하지 않는다.
* "무언가를 준비해 두고(given) 무언가를 실행한다(when)"는 모양이 계층마다 같기 때문에
* 이 클래스는 도메인이나 계층이 늘어나도 수정할 일이 없다.
*
* <p>실행 중 튀어나온 {@link RuntimeException}은 여기서 잡아 {@link Outcome}에 담는다.
* then 단계에서 "통과해야 한다 / 이 코드로 거부되어야 한다"를 판정하기 위해서다.
*
* <pre>{@code
* Scenario.given(fixture).when(RegistrationFixture::register).thenRejectedWith(REJECTIONS, code);
* JsonBody body = Scenario.given(api).when(a -> a.post(path, json)).thenAccepted();
* }</pre>
*
* @param <T> 계층별 fixture 타입 (메모리 빌더, 서비스, HTTP 클라이언트 …)
*/
public final class Scenario<T> {
private final T fixture;
@@ -26,17 +10,10 @@ public final class Scenario<T> {
this.fixture = fixture;
}
/** given: 준비된 fixture를 받는다. 어떻게 조립하는지는 각 도메인·계층이 안다. */
public static <T> Scenario<T> given(T fixture) {
return new Scenario<>(fixture);
}
/**
* when: fixture에 행동을 가하고 결과를 담아 돌려준다. 예외는 여기서 잡힌다.
*
* <p>값을 돌려주지 않는 행동은 fixture 자신을 반환하게 두면 된다. {@code when}이 하나뿐이라
* 계층이 달라져도 읽는 방식이 갈리지 않는다.
*/
public <R> Outcome<R> when(Function<T, R> action) {
try {
return new Outcome<>(action.apply(fixture), null);
@@ -44,4 +21,13 @@ public final class Scenario<T> {
return new Outcome<>(null, thrown);
}
}
public Outcome<Void> whenRunning(Consumer<T> action) {
try {
action.accept(fixture);
return new Outcome<>(null, null);
} catch (RuntimeException thrown) {
return new Outcome<>(null, thrown);
}
}
}
@@ -0,0 +1,101 @@
package com.study.course_registration.support.fixture;
import java.time.DayOfWeek;
import java.util.ArrayList;
import java.util.List;
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.entity.User;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.enums.UserRole;
import com.study.course_registration.repository.LessonRepository;
import com.study.course_registration.repository.LessonScheduleRepository;
import com.study.course_registration.repository.ProfessorRepository;
import com.study.course_registration.repository.RegistrationIdempotencyRepository;
import com.study.course_registration.repository.SemesterRepository;
import com.study.course_registration.repository.SubjectRepository;
import com.study.course_registration.repository.UserLessonRepository;
import com.study.course_registration.repository.UserRepository;
public final class DatabaseFixture {
private final RegistrationIdempotencyRepository idempotencies;
private final UserLessonRepository registrations;
private final LessonScheduleRepository schedules;
private final LessonRepository lessons;
private final SubjectRepository subjects;
private final ProfessorRepository professors;
private final SemesterRepository semesters;
private final UserRepository users;
public DatabaseFixture(RegistrationIdempotencyRepository idempotencies, UserLessonRepository registrations,
LessonScheduleRepository schedules, LessonRepository lessons, SubjectRepository subjects,
ProfessorRepository professors, SemesterRepository semesters, UserRepository users) {
this.idempotencies = idempotencies;
this.registrations = registrations;
this.schedules = schedules;
this.lessons = lessons;
this.subjects = subjects;
this.professors = professors;
this.semesters = semesters;
this.users = users;
}
public void reset() {
idempotencies.deleteAll();
registrations.deleteAll();
schedules.deleteAll();
lessons.deleteAll();
subjects.deleteAll();
professors.deleteAll();
semesters.deleteAll();
users.deleteAll();
}
public RegistrationDataset registrationDataset() {
reset();
Semester semester = semesters.save(DomainFixtures.openSemester());
Professor professor = professors.save(DomainFixtures.professor());
Subject subject = subjects.save(DomainFixtures.subject("CS101"));
User student = users.save(DomainFixtures.student(2));
Lesson lesson = lessons.save(DomainFixtures.lesson(subject, professor, semester));
schedules.save(DomainFixtures.schedule(lesson, DayOfWeek.MONDAY, 9, 11));
return new RegistrationDataset(semester, professor, subject, student, lesson);
}
public Semester semester(Semester semester) { return semesters.save(semester); }
public Professor professor(Professor professor) { return professors.save(professor); }
public Subject subject(Subject subject) { return subjects.save(subject); }
public User user(User user) { return users.save(user); }
public Lesson lesson(Lesson lesson) { return lessons.save(lesson); }
public LessonSchedule schedule(LessonSchedule schedule) { return schedules.save(schedule); }
public UserLesson registration(UserLesson registration) { return registrations.saveAndFlush(registration); }
public Lesson scheduledLesson(Semester semester, Professor professor, String code, int credit, int capacity,
DayOfWeek day, int startHour, int endHour) {
Subject subject = subject(DomainFixtures.subject(code, credit));
Lesson lesson = lesson(DomainFixtures.lesson(subject, professor, semester, capacity));
schedule(DomainFixtures.schedule(lesson, day, startHour, endHour));
return lesson;
}
public List<User> students(int count, String prefix) {
List<User> result = new ArrayList<>();
for (int index = 0; index < count; index++) {
result.add(users.save(new User(prefix + index, 2L, UserRole.STUDENT)));
}
return result;
}
public record RegistrationDataset(
Semester semester,
Professor professor,
Subject subject,
User student,
Lesson lesson) {
}
}
@@ -0,0 +1,151 @@
package com.study.course_registration.support.fixture;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalTime;
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.entity.User;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.enums.UserRole;
public final class DomainFixtures {
private DomainFixtures() {}
public static Semester openSemester() {
return openSemester(null, "2026-2", 18);
}
public static Semester openSemester(int maxCredits) {
return openSemester(null, "semester-" + maxCredits, maxCredits);
}
public static Semester openSemester(String id, String name, int maxCredits) {
return new Semester(id, name, TestData.TODAY.minusDays(20), TestData.TODAY.plusDays(100),
TestData.NOW.minusSeconds(3600), TestData.NOW.plusSeconds(3600), maxCredits);
}
public static Semester closedSemester() {
return closedSemester(null, "closed");
}
public static Semester closedSemester(String id, String name) {
return new Semester(id, name, TestData.TODAY.minusDays(100), TestData.TODAY.plusDays(100),
TestData.NOW.minusSeconds(7200), TestData.NOW.minusSeconds(3600), 18);
}
public static Semester academicSemester(String name) {
return new Semester(name, TestData.TODAY.minusDays(10), TestData.TODAY.plusDays(10),
TestData.NOW.minusSeconds(7200), TestData.NOW.minusSeconds(3600), 18);
}
public static Semester futureAcademicSemesterWithOpenRegistration() {
return new Semester("future-open", TestData.TODAY.plusDays(30), TestData.TODAY.plusDays(150),
TestData.NOW.minusSeconds(3600), TestData.NOW.plusSeconds(3600), 18);
}
public static Semester semester(
String id,
String name,
LocalDate startDate,
LocalDate endDate,
long registrationStartOffsetSeconds,
long registrationEndOffsetSeconds,
int maxCredits) {
return new Semester(id, name, startDate, endDate,
TestData.NOW.plusSeconds(registrationStartOffsetSeconds),
TestData.NOW.plusSeconds(registrationEndOffsetSeconds),
maxCredits);
}
public static Professor professor() {
return new Professor("교수");
}
public static Professor professor(String id) {
return new Professor(id, "교수-" + id);
}
public static Subject subject(String code) {
return subject(code, 3);
}
public static Subject subject(String code, int credit) {
return new Subject(code, code, code + " 설명", credit);
}
public static Subject subject(String id, String code, int credit) {
return new Subject(id, code, code, code + " 설명", credit);
}
public static User student(long grade) {
return new User("학생-" + grade, grade, UserRole.STUDENT);
}
public static User student(String id, long grade) {
return new User(id, "학생-" + id, grade, UserRole.STUDENT);
}
public static User studentNamed(String name, long grade) {
return new User(name, grade, UserRole.STUDENT);
}
public static User postgraduate() {
return new User("대학원생", 3L, UserRole.POSTGRADUATE);
}
public static Lesson lesson(Subject subject, Professor professor, Semester semester) {
return lesson(null, subject.getCode() + " 강의", subject, professor, semester, 30, null, null);
}
public static Lesson lesson(Subject subject, Professor professor, Semester semester, int capacity) {
return lesson(null, subject.getCode() + " 강의", subject, professor, semester, capacity, null, null);
}
public static Lesson lesson(
String id,
String name,
Subject subject,
Professor professor,
Semester semester,
int capacity,
Long minGrade,
UserRole allowedRole) {
return new Lesson(id, name, subject, professor, semester, capacity, minGrade, allowedRole);
}
public static LessonSchedule schedule(Lesson lesson, DayOfWeek day, int startHour, int endHour) {
return new LessonSchedule(lesson, day, LocalTime.of(startHour, 0), LocalTime.of(endHour, 0));
}
public static LessonSchedule schedule(String id, Lesson lesson, DayOfWeek day, int startHour, int endHour) {
return new LessonSchedule(id, lesson, day, LocalTime.of(startHour, 0), LocalTime.of(endHour, 0));
}
public static LessonSchedule schedule(DayOfWeek day, int startHour, int endHour) {
Semester semester = openSemester("fixture-semester-" + day + startHour, "fixture-" + day + startHour, 18);
Subject subject = subject("fixture-subject-" + day + startHour, "FIX" + day.getValue() + startHour, 3);
Lesson lesson = lesson(
"fixture-lesson-" + day + startHour,
"fixture-lesson",
subject,
professor("fixture-professor-" + day + startHour),
semester,
30,
null,
null);
return schedule("fixture-schedule-" + day + startHour, lesson, day, startHour, endHour);
}
public static UserLesson registration(User user, Lesson lesson) {
return new UserLesson(user, lesson);
}
public static UserLesson registration(String id, User user, Lesson lesson) {
return new UserLesson(id, user, lesson);
}
}
@@ -0,0 +1,11 @@
package com.study.course_registration.support.fixture;
import java.time.Instant;
import java.time.LocalDate;
public final class TestData {
public static final Instant NOW = Instant.parse("2026-09-21T03:00:00Z");
public static final LocalDate TODAY = LocalDate.of(2026, 9, 21);
private TestData() {}
}
@@ -0,0 +1,34 @@
package com.study.course_registration.support.fixture;
import java.time.Clock;
import java.time.ZoneOffset;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import com.study.course_registration.repository.LessonRepository;
import com.study.course_registration.repository.LessonScheduleRepository;
import com.study.course_registration.repository.ProfessorRepository;
import com.study.course_registration.repository.RegistrationIdempotencyRepository;
import com.study.course_registration.repository.SemesterRepository;
import com.study.course_registration.repository.SubjectRepository;
import com.study.course_registration.repository.UserLessonRepository;
import com.study.course_registration.repository.UserRepository;
@TestConfiguration(proxyBeanMethods = false)
public class TestFixtureConfig {
@Bean
@Primary
Clock testClock() {
return Clock.fixed(TestData.NOW, ZoneOffset.UTC);
}
@Bean
DatabaseFixture databaseFixture(RegistrationIdempotencyRepository idempotencies,
UserLessonRepository registrations, LessonScheduleRepository schedules,
LessonRepository lessons, SubjectRepository subjects, ProfessorRepository professors,
SemesterRepository semesters, UserRepository users) {
return new DatabaseFixture(idempotencies, registrations, schedules, lessons, subjects, professors, semesters, users);
}
}
@@ -1,39 +1,29 @@
package com.study.course_registration.support.http;
/**
* HTTP 응답이 4xx/5xx일 때 {@link JsonApi}가 던지는 예외.
*
* <p>HTTP는 예외를 던지지 않는다. 409는 던져진 게 아니라 <em>반환된 값</em>이다.
* 그대로 두면 단위·통합 계층과 표현법이 갈라지므로, 여기서 "거부 = 예외"로 번역해
* {@code Scenario.given(...).when(...).then(...)} 한 가지 흐름으로 읽히게 한다.
*
* <p>상태코드를 잃지 않도록 {@link #status()}를 그대로 들고 있는다. HTTP 계층에서만
* 볼 수 있는 값이 그것이기 때문이다.
*/
import java.util.Set;
import com.jayway.jsonpath.JsonPath;
public final class ApiError extends RuntimeException {
private final int status;
private final String code;
private final String detail;
private final String raw;
ApiError(int status, String code, String detail) {
ApiError(int status, String code, String detail, String raw) {
super("HTTP " + status + " " + code + " — " + detail);
this.status = status;
this.code = code;
this.detail = detail;
this.raw = raw;
}
/** 실제로 내려온 HTTP 상태코드 */
public int status() {
return status;
}
public int status() { return status; }
public String code() { return code; }
public String detail() { return detail; }
public String raw() { return raw; }
/** 응답 바디의 code 필드 (문자열 그대로. enum 변환은 도메인 쪽이 한다) */
public String code() {
return code;
}
/** 응답 바디의 message 필드 */
public String detail() {
return detail;
public Set<String> fieldNames() {
return JsonPath.<Set<String>>read(raw, "$.keys()");
}
}
@@ -10,14 +10,6 @@ import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import com.jayway.jsonpath.JsonPath;
/**
* MockMvc를 감싸 "2xx면 바디를 돌려주고, 4xx/5xx면 {@link ApiError}를 던지는" 클라이언트.
*
* <p>도메인을 모른다. 어떤 프로젝트의 어떤 엔드포인트에도 그대로 쓸 수 있고,
* 에러 바디가 {@code code}/{@code message} 필드를 갖는다는 것만 전제한다.
*
* <p>MockMvc를 여기서만 부르므로, 안쪽 API를 나중에 바꿔도 테스트는 그대로다.
*/
public final class JsonApi {
private final MockMvc mockMvc;
@@ -26,7 +18,12 @@ public final class JsonApi {
}
public JsonBody post(String path, String jsonBody) {
return exchange(MockMvcRequestBuilders.post(path).contentType(MediaType.APPLICATION_JSON).content(jsonBody));
}
public JsonBody post(String path, String jsonBody, String idempotencyKey) {
return exchange(MockMvcRequestBuilders.post(path)
.header("Idempotency-Key", idempotencyKey)
.contentType(MediaType.APPLICATION_JSON)
.content(jsonBody));
}
@@ -43,13 +40,13 @@ public final class JsonApi {
MockHttpServletResponse response;
try {
response = mockMvc.perform(request).andReturn().getResponse();
} catch (Exception e) {
throw new IllegalStateException("요청을 보내지 못했다: " + request, e);
} catch (Exception exception) {
throw new IllegalStateException("요청을 보내지 못했습니다.", exception);
}
String body = readBody(response);
if (response.getStatus() >= 400) {
throw new ApiError(response.getStatus(), readField(body, "$.code"), readField(body, "$.message"));
throw new ApiError(response.getStatus(), readField(body, "$.code"), readField(body, "$.message"), body);
}
return new JsonBody(response.getStatus(), body);
}
@@ -58,19 +55,17 @@ public final class JsonApi {
try {
response.setCharacterEncoding(StandardCharsets.UTF_8.name());
return response.getContentAsString(StandardCharsets.UTF_8);
} catch (Exception e) {
throw new IllegalStateException("응답 본문을 읽지 못했다", e);
} catch (Exception exception) {
throw new IllegalStateException("응답 본문을 읽지 못했습니다.", exception);
}
}
private static String readField(String body, String path) {
if (body == null || body.isBlank()) {
return "(빈 응답 본문)";
}
if (body == null || body.isBlank()) return "(빈 응답 본문)";
try {
return String.valueOf(JsonPath.<Object>read(body, path));
} catch (RuntimeException e) {
return "(" + path + " 없음: " + body + ")";
} catch (RuntimeException exception) {
return "(" + path + " 없음)";
}
}
}
@@ -2,16 +2,8 @@ package com.study.course_registration.support.http;
import java.util.Set;
import com.jayway.jsonpath.DocumentContext;
import com.jayway.jsonpath.JsonPath;
/**
* 2xx 응답. 상태코드와 본문을 함께 들고 있다.
*
* <p>상태코드를 여기 싣는 이유: {@code thenAccepted()}는 "거부되지 않았다"까지만 판정한다.
* 201과 200을 구분하는 건 그 다음 질문이고, 그 질문에 답할 값이 없으면
* "201을 돌려준다"고 이름 붙인 테스트가 200에서도 통과한다.
*/
public final class JsonBody {
private final int status;
private final String raw;
@@ -21,28 +13,8 @@ public final class JsonBody {
this.raw = raw;
}
/** 실제로 내려온 HTTP 상태코드 */
public int status() {
return status;
}
/** 예: {@code body.at("$.totalCredits")} */
public <T> T at(String jsonPath) {
return JsonPath.read(raw, jsonPath);
}
/**
* 최상위 필드 이름 전부. 응답 스키마를 통째로 고정할 때 쓴다.
*
* <p>값이 아니라 <em>이름</em>을 보는 이유: 필드 이름은 클라이언트와의 계약이다.
* 값 몇 개만 확인하면 이름이 바뀌어도 테스트가 통과한다.
*/
public Set<String> fieldNames() {
DocumentContext ctx = JsonPath.parse(raw);
return ctx.read("$.keys()", Set.class);
}
public String raw() {
return raw;
}
public int status() { return status; }
public <T> T at(String jsonPath) { return JsonPath.read(raw, jsonPath); }
public Set<String> fieldNames() { return JsonPath.read(raw, "$.keys()"); }
public String raw() { return raw; }
}
+9 -3
View File
@@ -1,19 +1,25 @@
spring:
datasource:
url: jdbc:h2:mem:course_test;DB_CLOSE_DELAY=-1;MODE=PostgreSQL;LOCK_TIMEOUT=3000
driver-class-name: org.h2.Driver
username: sa
password:
flyway:
locations: classpath:db/migration/h2
jpa:
hibernate:
ddl-auto: create-drop
open-in-view: false
hibernate:
ddl-auto: validate
properties:
hibernate:
generate_statistics: true
h2:
console:
enabled: false
app:
seed:
enabled: false
springdoc:
api-docs:
enabled: false
@@ -0,0 +1,2 @@
a b
1
1 a b
2 1
+2
View File
@@ -0,0 +1,2 @@
name optional number
alpha 3
1 name optional number
2 alpha 3