refactor: 공통 로직 분리

This commit is contained in:
donghyeon-ka
2026-09-23 17:15:13 +09:00
parent 44f80fca3b
commit d9eaff4c5e
21 changed files with 322 additions and 160 deletions
+5 -1
View File
@@ -211,12 +211,16 @@ ID는 현재 Java에서 `String UUID`, DB에서 `VARCHAR(36)`을 유지합니다
fixture/
http/
support/Scenario의 흐름을 계층에 관계없이 재사용합니다.
업무 행동을 검증하는 API/Application Integration/Repository Integration/Domain Policy/Concurrency 테스트는 `support/Scenario`의 GWT 흐름을 사용합니다.
given(fixture)
-> when(action) / whenRunning(action)
-> then(assertions) / thenRejectedWith
mock 기반 Unit Test는 `BDDMockito.given(...)`으로 준비하고 `BDDMockito.then(...).should(...)`로 interaction을 검증합니다. Pure Function/Parameterized/Entity Invariant/Architecture/Config 테스트는 직접 assertion을 허용합니다.
세부 기준과 Domain validation contract는 `docs/testing-and-domain-validation-conventions.md`를 기준으로 합니다.
fixture는 support/fixture에 모읍니다.
- DomainFixtures: 순수 도메인 객체
@@ -0,0 +1,62 @@
# Test and Domain Validation Conventions
이 문서는 테스트의 Given / When / Then 문법과 Domain/JPA model validation 기준을 고정한다.
## Test language
테스트 종류에 따라 하나의 문법을 선택한다.
| 테스트 성격 | 기준 |
|---|---|
| API / Controller | `Scenario.given(...).when(...).then(...)` |
| Application Integration | `Scenario` GWT |
| Repository Integration | `Scenario` GWT |
| Domain Policy | `Scenario` GWT |
| Concurrency Scenario | `Scenario` GWT |
| Mock 기반 Unit | `BDDMockito.given(...)` / `BDDMockito.then(...).should(...)` |
| Pure Function / Parameterized | 직접 assertion 허용 |
| Entity Invariant | 직접 assertion 허용 |
| Architecture / Source / Config | 직접 assertion 허용 |
`Mockito.when(...)`은 행동 실행이 아니라 mock setup이므로 사용하지 않는다. mock setup은 `given(...).willReturn(...)`, interaction 검증은 `then(mock).should(...)`를 사용한다.
`Scenario`를 사용하는 경우 `.when(...)` 또는 `.whenRunning(...)` 뒤에는 반드시 terminal assertion이 있어야 한다. `ScenarioUsageTest`가 이 규칙을 검사한다.
`SourceStyleTest`는 classic Mockito의 `when/verify` 계열 사용을 금지한다. `times`, `never`, `inOrder`, `mock`처럼 BDDMockito의 given/then 의미를 훼손하지 않는 Mockito utility는 허용한다.
## Validation contract
기계적인 invariant는 `domain.validation.Require`만 사용한다.
| 값의 의미 | 사용 규칙 |
|---|---|
| 필수 일반 객체 | `Require.nonNull` |
| 필수 String | `Require.text` |
| 필수 양수 `Integer` / `Long` | `Require.positive` |
| 선택 양수 `Long` | `Require.positiveIfPresent` |
| 선택 String | 해당 경계에서 normalize하거나 null/empty 의미를 명시 |
| 두 필드 사이 관계 | Entity / Value Object / Snapshot 내부 invariant |
`Require.text`는 null, empty, blank를 모두 거부한다. `Require.nonNull`은 null만 거부한다. 둘은 같은 검증이 아니다.
다음과 같은 관계 invariant는 공통 Guard로 옮기지 않는다.
- `LessonSchedule.startTime < endTime`
- `Semester.startDate <= endDate`
- `Semester.registrationStartAt < registrationEndAt`
- `LessonPolicySnapshot.registrationStartAt < registrationEndAt`
- `RegistrationDecisionSnapshot.enrolledCount >= 0`
optional normalization도 required invariant와 구분한다. 예를 들어 `Subject.description == null`은 빈 문자열로 normalize하고, optional request parameter나 idempotency header의 blank 처리는 application/infrastructure 경계에서 별도로 처리한다.
## Value Object selection
이번 리팩터링에서는 primitive/String을 일괄 Value Object로 올리지 않는다.
- `Credit`: 여러 위치에 있지만 현재 독립 행동보다 positive invariant 비중이 크다. `Require.positive`로 중복을 제거하고 유지한다.
- `Grade`: 동일하다. 별도 타입이 필요한 정책 행동이 늘어날 때 재검토한다.
- `Capacity`: 동일하다. 정원 경쟁 자체는 registration policy/locking 책임이며 숫자 타입의 행동은 아직 없다.
- `RegistrationWindow`: cross-field 의미와 행동이 있어 가장 강한 Domain VO 후보지만 현재 `LessonPolicySnapshot` 한 곳이 소유한다. 재사용 경계가 생길 때 추출한다.
- `IdempotencyKey`: business domain이 아니라 registration application concern이다. 별도 타입이 필요해지면 Domain VO가 아니라 application boundary value로 둔다.
Value Object는 같은 검증이 반복된다는 이유만으로 만들지 않는다. 도메인 의미, 타입 혼동 위험, 관련 행동, 규칙 확장성 중 하나 이상이 실제로 커질 때 도입한다.
@@ -1,8 +1,8 @@
package com.study.course_registration.domain.registration;
import java.time.Instant;
import java.util.Objects;
import com.study.course_registration.domain.validation.Require;
import com.study.course_registration.enums.UserRole;
public record LessonPolicySnapshot(
@@ -20,39 +20,31 @@ public record LessonPolicySnapshot(
UserRole allowedRole) {
public LessonPolicySnapshot {
Objects.requireNonNull(id, "id");
Objects.requireNonNull(name, "name");
Objects.requireNonNull(subjectId, "subjectId");
Objects.requireNonNull(subjectCode, "subjectCode");
Objects.requireNonNull(semesterId, "semesterId");
Objects.requireNonNull(registrationStartAt, "registrationStartAt");
Objects.requireNonNull(registrationEndAt, "registrationEndAt");
if (subjectCredit < 1) {
throw new IllegalArgumentException("subjectCredit must be at least 1");
}
if (maxCredits < 1) {
throw new IllegalArgumentException("maxCredits must be at least 1");
}
if (capacity < 1) {
throw new IllegalArgumentException("capacity must be at least 1");
}
if (minGrade != null && minGrade < 1) {
throw new IllegalArgumentException("minGrade must be at least 1");
}
id = Require.text(id, "id");
name = Require.text(name, "name");
subjectId = Require.text(subjectId, "subjectId");
subjectCode = Require.text(subjectCode, "subjectCode");
semesterId = Require.text(semesterId, "semesterId");
registrationStartAt = Require.nonNull(registrationStartAt, "registrationStartAt");
registrationEndAt = Require.nonNull(registrationEndAt, "registrationEndAt");
subjectCredit = Require.positive(subjectCredit, "subjectCredit");
maxCredits = Require.positive(maxCredits, "maxCredits");
capacity = Require.positive(capacity, "capacity");
minGrade = Require.positiveIfPresent(minGrade, "minGrade");
if (!registrationStartAt.isBefore(registrationEndAt)) {
throw new IllegalArgumentException("registrationStartAt must be before registrationEndAt");
}
}
public void verifyRegistrationWindow(Instant now) {
Objects.requireNonNull(now, "now");
Require.nonNull(now, "now");
if (now.isBefore(registrationStartAt) || now.isAfter(registrationEndAt)) {
throw RegistrationRejection.registrationPeriodClosed();
}
}
public void verifyStudentEligibility(UserProfile user) {
Objects.requireNonNull(user, "user");
Require.nonNull(user, "user");
if (minGrade != null && user.grade() < minGrade) {
throw RegistrationRejection.notEligibleGrade(user.grade(), minGrade);
}
@@ -5,8 +5,8 @@ import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import com.study.course_registration.domain.validation.Require;
import com.study.course_registration.domain.schedule.ScheduleSlot;
public record RegistrationDecisionSnapshot(
@@ -18,11 +18,11 @@ public record RegistrationDecisionSnapshot(
Instant now) {
public RegistrationDecisionSnapshot {
Objects.requireNonNull(user, "user");
Objects.requireNonNull(lesson, "lesson");
Objects.requireNonNull(activeRegistrations, "activeRegistrations");
Objects.requireNonNull(schedulesByLessonId, "schedulesByLessonId");
Objects.requireNonNull(now, "now");
user = Require.nonNull(user, "user");
lesson = Require.nonNull(lesson, "lesson");
activeRegistrations = Require.nonNull(activeRegistrations, "activeRegistrations");
schedulesByLessonId = Require.nonNull(schedulesByLessonId, "schedulesByLessonId");
now = Require.nonNull(now, "now");
if (enrolledCount < 0) {
throw RegistrationInvariantViolation.negativeEnrolledCount();
}
@@ -30,8 +30,8 @@ public record RegistrationDecisionSnapshot(
activeRegistrations = List.copyOf(activeRegistrations);
Map<String, List<ScheduleSlot>> copiedSchedules = new LinkedHashMap<>();
schedulesByLessonId.forEach((lessonId, slots) -> copiedSchedules.put(
Objects.requireNonNull(lessonId, "schedule lessonId"),
List.copyOf(Objects.requireNonNull(slots, "schedule slots"))));
Require.text(lessonId, "schedule lessonId"),
List.copyOf(Require.nonNull(slots, "schedule slots"))));
schedulesByLessonId = Collections.unmodifiableMap(copiedSchedules);
}
@@ -1,7 +1,7 @@
package com.study.course_registration.domain.registration;
import java.util.Objects;
import com.study.course_registration.domain.validation.Require;
import com.study.course_registration.enums.UserRole;
public record UserProfile(
@@ -10,10 +10,8 @@ public record UserProfile(
UserRole role) {
public UserProfile {
Objects.requireNonNull(id, "id");
Objects.requireNonNull(role, "role");
if (grade < 1) {
throw new IllegalArgumentException("grade must be at least 1");
}
id = Require.text(id, "id");
role = Require.nonNull(role, "role");
grade = Require.positive(grade, "grade");
}
}
@@ -0,0 +1,40 @@
package com.study.course_registration.domain.validation;
import java.util.Objects;
public final class Require {
private Require() {
}
public static <T> T nonNull(T value, String field) {
return Objects.requireNonNull(value, field);
}
public static String text(String value, String field) {
if (value == null || value.isBlank()) {
throw new IllegalArgumentException(field + " must not be blank");
}
return value;
}
public static int positive(Integer value, String field) {
if (value == null || value < 1) {
throw new IllegalArgumentException(field + " must be at least 1");
}
return value;
}
public static long positive(Long value, String field) {
if (value == null || value < 1) {
throw new IllegalArgumentException(field + " must be at least 1");
}
return value;
}
public static Long positiveIfPresent(Long value, String field) {
if (value != null && value < 1) {
throw new IllegalArgumentException(field + " must be at least 1 when present");
}
return value;
}
}
@@ -1,9 +1,9 @@
package com.study.course_registration.entity;
import java.util.Objects;
import com.study.course_registration.enums.UserRole;
import com.study.course_registration.domain.validation.Require;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
@@ -52,21 +52,12 @@ public class Lesson extends BaseTimeZoneEntity {
public Lesson(String id, String name, Subject subject, Professor professor, Semester semester,
Integer capacity, Long minGrade, UserRole allowedRole) {
super(id);
if (name == null || name.isBlank()) {
throw new IllegalArgumentException("name must not be blank");
}
if (capacity == null || capacity < 1) {
throw new IllegalArgumentException("capacity must be at least 1");
}
if (minGrade != null && minGrade < 1) {
throw new IllegalArgumentException("minGrade must be at least 1 when present");
}
this.name = name;
this.subject = Objects.requireNonNull(subject, "subject");
this.professor = Objects.requireNonNull(professor, "professor");
this.semester = Objects.requireNonNull(semester, "semester");
this.capacity = capacity;
this.minGrade = minGrade;
this.name = Require.text(name, "name");
this.subject = Require.nonNull(subject, "subject");
this.professor = Require.nonNull(professor, "professor");
this.semester = Require.nonNull(semester, "semester");
this.capacity = Require.positive(capacity, "capacity");
this.minGrade = Require.positiveIfPresent(minGrade, "minGrade");
this.allowedRole = allowedRole;
}
}
@@ -2,8 +2,8 @@ package com.study.course_registration.entity;
import java.time.DayOfWeek;
import java.time.LocalTime;
import java.util.Objects;
import com.study.course_registration.domain.validation.Require;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
@@ -39,10 +39,10 @@ public class LessonSchedule extends BaseTimeZoneEntity {
public LessonSchedule(String id, Lesson lesson, DayOfWeek dayOfWeek, LocalTime startTime, LocalTime endTime) {
super(id);
this.lesson = Objects.requireNonNull(lesson, "lesson");
this.dayOfWeek = Objects.requireNonNull(dayOfWeek, "dayOfWeek");
this.startTime = Objects.requireNonNull(startTime, "startTime");
this.endTime = Objects.requireNonNull(endTime, "endTime");
this.lesson = Require.nonNull(lesson, "lesson");
this.dayOfWeek = Require.nonNull(dayOfWeek, "dayOfWeek");
this.startTime = Require.nonNull(startTime, "startTime");
this.endTime = Require.nonNull(endTime, "endTime");
if (!startTime.isBefore(endTime)) {
throw new IllegalArgumentException("startTime must be before endTime");
}
@@ -1,5 +1,6 @@
package com.study.course_registration.entity;
import com.study.course_registration.domain.validation.Require;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
@@ -21,9 +22,6 @@ public class Professor extends BaseTimeZoneEntity {
public Professor(String id, String name) {
super(id);
if (name == null || name.isBlank()) {
throw new IllegalArgumentException("name must not be blank");
}
this.name = name;
this.name = Require.text(name, "name");
}
}
@@ -2,8 +2,8 @@ package com.study.course_registration.entity;
import java.time.Instant;
import java.time.LocalDate;
import java.util.Objects;
import com.study.course_registration.domain.validation.Require;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
@@ -43,27 +43,18 @@ public class Semester extends BaseTimeZoneEntity {
public Semester(String id, String name, LocalDate startDate, LocalDate endDate,
Instant registrationStartAt, Instant registrationEndAt, Integer maxCredits) {
super(id);
this.name = requireText(name, "name");
this.startDate = Objects.requireNonNull(startDate, "startDate");
this.endDate = Objects.requireNonNull(endDate, "endDate");
this.registrationStartAt = Objects.requireNonNull(registrationStartAt, "registrationStartAt");
this.registrationEndAt = Objects.requireNonNull(registrationEndAt, "registrationEndAt");
this.name = Require.text(name, "name");
this.startDate = Require.nonNull(startDate, "startDate");
this.endDate = Require.nonNull(endDate, "endDate");
this.registrationStartAt = Require.nonNull(registrationStartAt, "registrationStartAt");
this.registrationEndAt = Require.nonNull(registrationEndAt, "registrationEndAt");
if (endDate.isBefore(startDate)) {
throw new IllegalArgumentException("endDate must be on or after startDate");
}
if (!registrationStartAt.isBefore(registrationEndAt)) {
throw new IllegalArgumentException("registrationStartAt must be before registrationEndAt");
}
if (maxCredits == null || maxCredits < 1) {
throw new IllegalArgumentException("maxCredits must be at least 1");
}
this.maxCredits = maxCredits;
this.maxCredits = Require.positive(maxCredits, "maxCredits");
}
private static String requireText(String value, String field) {
if (value == null || value.isBlank()) {
throw new IllegalArgumentException(field + " must not be blank");
}
return value;
}
}
@@ -1,5 +1,6 @@
package com.study.course_registration.entity;
import com.study.course_registration.domain.validation.Require;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
@@ -31,19 +32,10 @@ public class Subject extends BaseTimeZoneEntity {
public Subject(String id, String name, String code, String description, Integer credit) {
super(id);
if (credit == null || credit < 1) {
throw new IllegalArgumentException("credit must be at least 1");
}
this.name = requireText(name, "name");
this.code = requireText(code, "code");
this.name = Require.text(name, "name");
this.code = Require.text(code, "code");
this.description = description == null ? "" : description;
this.credit = credit;
this.credit = Require.positive(credit, "credit");
}
private static String requireText(String value, String field) {
if (value == null || value.isBlank()) {
throw new IllegalArgumentException(field + " must not be blank");
}
return value;
}
}
@@ -1,9 +1,9 @@
package com.study.course_registration.entity;
import java.util.Objects;
import com.study.course_registration.enums.UserRole;
import com.study.course_registration.domain.validation.Require;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
@@ -31,14 +31,8 @@ public class User extends BaseTimeZoneEntity {
public User(String id, String name, Long grade, UserRole role) {
super(id);
if (name == null || name.isBlank()) {
throw new IllegalArgumentException("name must not be blank");
}
if (grade == null || grade < 1) {
throw new IllegalArgumentException("grade must be at least 1");
}
this.name = name;
this.grade = grade;
this.role = Objects.requireNonNull(role, "role");
this.name = Require.text(name, "name");
this.grade = Require.positive(grade, "grade");
this.role = Require.nonNull(role, "role");
}
}
@@ -1,8 +1,8 @@
package com.study.course_registration.entity;
import java.time.Instant;
import java.util.Objects;
import com.study.course_registration.domain.validation.Require;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
@@ -36,13 +36,13 @@ public class UserLesson extends BaseCreateEntity {
public UserLesson(String id, User user, Lesson lesson) {
super(id);
this.user = Objects.requireNonNull(user, "user");
this.lesson = Objects.requireNonNull(lesson, "lesson");
this.user = Require.nonNull(user, "user");
this.lesson = Require.nonNull(lesson, "lesson");
}
public void cancel(Instant canceledAt) {
if (this.canceledAt == null) {
this.canceledAt = Objects.requireNonNull(canceledAt, "canceledAt");
this.canceledAt = Require.nonNull(canceledAt, "canceledAt");
}
}
@@ -1,13 +1,13 @@
package com.study.course_registration.infrastructure.persistence.idempotency;
import java.time.Instant;
import java.util.Objects;
import com.study.course_registration.entity.BaseCreateEntity;
import com.study.course_registration.entity.Lesson;
import com.study.course_registration.entity.User;
import com.study.course_registration.entity.UserLesson;
import com.study.course_registration.domain.validation.Require;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
@@ -75,31 +75,19 @@ public class RegistrationIdempotencyEntity extends BaseCreateEntity {
Instant registeredAt,
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) {
this.user = Require.nonNull(user, "user");
this.lesson = Require.nonNull(lesson, "lesson");
this.registration = Require.nonNull(registration, "registration");
this.idempotencyKey = Require.text(idempotencyKey, "idempotencyKey");
if (idempotencyKey.length() > 100) {
throw new IllegalArgumentException("idempotencyKey length must be 1..100");
}
this.idempotencyKey = idempotencyKey;
this.lessonName = requireText(lessonName, "lessonName");
this.subjectCode = requireText(subjectCode, "subjectCode");
if (credit == null || credit < 1) {
throw new IllegalArgumentException("credit must be at least 1");
}
this.credit = credit;
this.registeredAt = Objects.requireNonNull(registeredAt, "registeredAt");
if (totalCredits == null || totalCredits < 1) {
throw new IllegalArgumentException("totalCredits must be at least 1");
}
this.totalCredits = totalCredits;
this.expiresAt = Objects.requireNonNull(expiresAt, "expiresAt");
this.lessonName = Require.text(lessonName, "lessonName");
this.subjectCode = Require.text(subjectCode, "subjectCode");
this.credit = Require.positive(credit, "credit");
this.registeredAt = Require.nonNull(registeredAt, "registeredAt");
this.totalCredits = Require.positive(totalCredits, "totalCredits");
this.expiresAt = Require.nonNull(expiresAt, "expiresAt");
}
private static String requireText(String value, String field) {
if (value == null || value.isBlank()) {
throw new IllegalArgumentException(field + " must not be blank");
}
return value;
}
}
@@ -3,8 +3,8 @@ package com.study.course_registration.application.registration;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.then;
import java.time.Clock;
import java.time.ZoneOffset;
@@ -48,9 +48,9 @@ class RegisterCourseUseCaseTest {
TestData.NOW,
3);
when(scopes.open("user", "lesson")).thenReturn(scope);
when(idempotency.evaluate("user", "lesson", "retry", TestData.NOW))
.thenReturn(new Decision("retry", Optional.of(replay)));
given(scopes.open("user", "lesson")).willReturn(scope);
given(idempotency.evaluate("user", "lesson", "retry", TestData.NOW))
.willReturn(new Decision("retry", Optional.of(replay)));
RegisterCourseUseCase useCase = new RegisterCourseUseCase(
Clock.fixed(TestData.NOW, ZoneOffset.UTC),
@@ -65,10 +65,13 @@ class RegisterCourseUseCaseTest {
new RegisterCourseCommand("user", "lesson", "retry"));
InOrder order = inOrder(scopes, idempotency);
order.verify(scopes).open("user", "lesson");
order.verify(idempotency).evaluate("user", "lesson", "retry", TestData.NOW);
then(scopes).should(order).open("user", "lesson");
then(idempotency).should(order).evaluate("user", "lesson", "retry", TestData.NOW);
verifyNoInteractions(contexts, registrations, policy, windowGuard);
then(contexts).shouldHaveNoInteractions();
then(registrations).shouldHaveNoInteractions();
then(policy).shouldHaveNoInteractions();
then(windowGuard).shouldHaveNoInteractions();
assertThat(result.registrationId()).isEqualTo("registration");
assertThat(result.registeredAt()).isEqualTo(TestData.NOW);
}
@@ -2,8 +2,8 @@ package com.study.course_registration.application.registration.idempotency;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.then;
import java.time.Duration;
import java.time.ZoneOffset;
@@ -23,17 +23,17 @@ class CleanupIdempotencyUseCaseTest {
IdempotencyPort idempotencies = mock(IdempotencyPort.class);
CleanupIdempotencyUseCase useCase =
new CleanupIdempotencyUseCase(clock, idempotencies, 500);
when(idempotencies.deleteExpiredBatch(TestData.NOW, 500)).thenReturn(23);
given(idempotencies.deleteExpiredBatch(TestData.NOW, 500)).willReturn(23);
int deleted = useCase.execute();
assertThat(deleted).isEqualTo(23);
verify(idempotencies).deleteExpiredBatch(TestData.NOW, 500);
then(idempotencies).should().deleteExpiredBatch(TestData.NOW, 500);
clock.advance(Duration.ofSeconds(1));
when(idempotencies.deleteExpiredBatch(TestData.NOW.plusSeconds(1), 500)).thenReturn(0);
given(idempotencies.deleteExpiredBatch(TestData.NOW.plusSeconds(1), 500)).willReturn(0);
assertThat(useCase.execute()).isZero();
verify(idempotencies).deleteExpiredBatch(TestData.NOW.plusSeconds(1), 500);
then(idempotencies).should().deleteExpiredBatch(TestData.NOW.plusSeconds(1), 500);
}
}
@@ -17,9 +17,11 @@ 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_$]*");
private static final Pattern CLASSIC_MOCKITO_GWT = Pattern.compile(
"org\\.mockito\\.Mockito\\.(?:when|verify|verifyNoInteractions|verifyNoMoreInteractions)");
@Test
@DisplayName("소스 스타일 → var·본문 FQCN·wildcard import 금지")
@DisplayName("소스 스타일 → var·본문 FQCN·wildcard import·classic Mockito GWT 금지")
void sourceStyle() throws IOException {
List<String> violations = new ArrayList<>();
@@ -31,7 +33,7 @@ class SourceStyleTest {
}
assertThat(violations)
.as("명시적 타입/import 규칙 위반")
.as("소스 스타일/테스트 문법 규칙 위반")
.isEmpty();
}
@@ -48,6 +50,10 @@ class SourceStyleTest {
if (LOCAL_VAR.matcher(line).find()) {
violations.add(location(path, index, "var"));
}
if (path.startsWith(Path.of("src/test/java"))
&& CLASSIC_MOCKITO_GWT.matcher(line).find()) {
violations.add(location(path, index, "classic Mockito when/verify"));
}
if (!trimmed.startsWith("package ")
&& !trimmed.startsWith("import ")
&& FQCN.matcher(line).find()) {
@@ -0,0 +1,37 @@
package com.study.course_registration.domain.registration;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
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.TestData;
class DomainValidationContractTest {
@Test
@DisplayName("LessonPolicySnapshot 필수 text → blank 거부")
void lessonPolicySnapshotRejectsBlankRequiredText() {
assertThatThrownBy(() -> new LessonPolicySnapshot(
"lesson",
" ",
"subject",
"CS101",
3,
"semester",
TestData.NOW.minusSeconds(1),
TestData.NOW.plusSeconds(1),
18,
30,
null,
null))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("UserProfile id → blank 거부")
void userProfileRejectsBlankId() {
assertThatThrownBy(() -> new UserProfile(" ", 1, UserRole.STUDENT))
.isInstanceOf(IllegalArgumentException.class);
}
}
@@ -0,0 +1,64 @@
package com.study.course_registration.domain.validation;
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 RequireTest {
@Test
@DisplayName("nonNull → null만 거부")
void nonNullRejectsOnlyNull() {
assertThat(Require.nonNull("", "value")).isEmpty();
assertThatThrownBy(() -> Require.nonNull(null, "value"))
.isInstanceOf(NullPointerException.class);
}
@Test
@DisplayName("text → null·empty·blank 거부")
void textRejectsMissingText() {
assertThat(Require.text("value", "field")).isEqualTo("value");
assertThatThrownBy(() -> Require.text(null, "field"))
.isInstanceOf(IllegalArgumentException.class);
assertThatThrownBy(() -> Require.text("", "field"))
.isInstanceOf(IllegalArgumentException.class);
assertThatThrownBy(() -> Require.text(" ", "field"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("positive Integer → null·0·음수 거부, 1 허용")
void positiveIntegerRequiresAtLeastOne() {
assertThat(Require.positive(1, "value")).isEqualTo(1);
assertThatThrownBy(() -> Require.positive((Integer) null, "value"))
.isInstanceOf(IllegalArgumentException.class);
assertThatThrownBy(() -> Require.positive(0, "value"))
.isInstanceOf(IllegalArgumentException.class);
assertThatThrownBy(() -> Require.positive(-1, "value"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("positive Long → null·0·음수 거부, 1 허용")
void positiveLongRequiresAtLeastOne() {
assertThat(Require.positive(1L, "value")).isEqualTo(1L);
assertThatThrownBy(() -> Require.positive((Long) null, "value"))
.isInstanceOf(IllegalArgumentException.class);
assertThatThrownBy(() -> Require.positive(0L, "value"))
.isInstanceOf(IllegalArgumentException.class);
assertThatThrownBy(() -> Require.positive(-1L, "value"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("positiveIfPresent → null 허용, 0·음수 거부")
void positiveIfPresentAllowsNull() {
assertThat(Require.positiveIfPresent(null, "value")).isNull();
assertThat(Require.positiveIfPresent(1L, "value")).isEqualTo(1L);
assertThatThrownBy(() -> Require.positiveIfPresent(0L, "value"))
.isInstanceOf(IllegalArgumentException.class);
assertThatThrownBy(() -> Require.positiveIfPresent(-1L, "value"))
.isInstanceOf(IllegalArgumentException.class);
}
}
@@ -3,8 +3,8 @@ package com.study.course_registration.infrastructure.persistence;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.then;
import java.util.Optional;
@@ -31,8 +31,8 @@ class JpaRegistrationExecutionScopeLoaderTest {
DomainFixtures.professor(),
DomainFixtures.openSemester());
when(users.findByIdForUpdate("user")).thenReturn(Optional.of(user));
when(lessons.findByIdForUpdate("lesson")).thenReturn(Optional.of(lesson));
given(users.findByIdForUpdate("user")).willReturn(Optional.of(user));
given(lessons.findByIdForUpdate("lesson")).willReturn(Optional.of(lesson));
JpaRegistrationExecutionScopeLoader loader =
new JpaRegistrationExecutionScopeLoader(users, lessons);
@@ -41,12 +41,12 @@ class JpaRegistrationExecutionScopeLoaderTest {
assertThat(scope.userId()).isEqualTo("user");
assertThat(scope.lessonId()).isEqualTo("lesson");
verifyNoInteractions(lessons);
then(lessons).shouldHaveNoInteractions();
loader.lockLesson(scope);
InOrder order = inOrder(users, lessons);
order.verify(users).findByIdForUpdate("user");
order.verify(lessons).findByIdForUpdate("lesson");
then(users).should(order).findByIdForUpdate("user");
then(lessons).should(order).findByIdForUpdate("lesson");
}
}
@@ -2,9 +2,11 @@ package com.study.course_registration.infrastructure.scheduling;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.then;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import java.util.OptionalInt;
import java.util.function.IntSupplier;
@@ -20,14 +22,14 @@ class IdempotencyRetentionJobTest {
void cleanupStopsOnEmptyBatch() {
CleanupIdempotencyUseCase cleanup = mock(CleanupIdempotencyUseCase.class);
DatabaseJobLock jobLock = mock(DatabaseJobLock.class);
when(jobLock.callWithLock(eq(IdempotencyRetentionJob.LOCK_NAME), any(IntSupplier.class)))
.thenAnswer(invocation -> OptionalInt.of(invocation.<IntSupplier>getArgument(1).getAsInt()));
when(cleanup.execute()).thenReturn(500, 3, 0);
given(jobLock.callWithLock(eq(IdempotencyRetentionJob.LOCK_NAME), any(IntSupplier.class)))
.willAnswer(invocation -> OptionalInt.of(invocation.<IntSupplier>getArgument(1).getAsInt()));
given(cleanup.execute()).willReturn(500, 3, 0);
IdempotencyRetentionJob job = new IdempotencyRetentionJob(cleanup, jobLock, 20);
job.cleanup();
verify(cleanup, org.mockito.Mockito.times(3)).execute();
then(cleanup).should(times(3)).execute();
}
@Test
@@ -35,11 +37,11 @@ class IdempotencyRetentionJobTest {
void cleanupSkipsWhenLockIsOwnedByAnotherInstance() {
CleanupIdempotencyUseCase cleanup = mock(CleanupIdempotencyUseCase.class);
DatabaseJobLock jobLock = mock(DatabaseJobLock.class);
when(jobLock.callWithLock(eq(IdempotencyRetentionJob.LOCK_NAME), any(IntSupplier.class)))
.thenReturn(OptionalInt.empty());
given(jobLock.callWithLock(eq(IdempotencyRetentionJob.LOCK_NAME), any(IntSupplier.class)))
.willReturn(OptionalInt.empty());
new IdempotencyRetentionJob(cleanup, jobLock, 20).cleanup();
verify(cleanup, org.mockito.Mockito.never()).execute();
then(cleanup).should(never()).execute();
}
}