diff --git a/README.md b/README.md index 24d96f1..b4f1c7b 100644 --- a/README.md +++ b/README.md @@ -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: 순수 도메인 객체 diff --git a/docs/testing-and-domain-validation-conventions.md b/docs/testing-and-domain-validation-conventions.md new file mode 100644 index 0000000..72c4fb7 --- /dev/null +++ b/docs/testing-and-domain-validation-conventions.md @@ -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는 같은 검증이 반복된다는 이유만으로 만들지 않는다. 도메인 의미, 타입 혼동 위험, 관련 행동, 규칙 확장성 중 하나 이상이 실제로 커질 때 도입한다. diff --git a/src/main/java/com/study/course_registration/domain/registration/LessonPolicySnapshot.java b/src/main/java/com/study/course_registration/domain/registration/LessonPolicySnapshot.java index b47c172..0180ce9 100644 --- a/src/main/java/com/study/course_registration/domain/registration/LessonPolicySnapshot.java +++ b/src/main/java/com/study/course_registration/domain/registration/LessonPolicySnapshot.java @@ -1,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); } diff --git a/src/main/java/com/study/course_registration/domain/registration/RegistrationDecisionSnapshot.java b/src/main/java/com/study/course_registration/domain/registration/RegistrationDecisionSnapshot.java index 9789f20..48b87cb 100644 --- a/src/main/java/com/study/course_registration/domain/registration/RegistrationDecisionSnapshot.java +++ b/src/main/java/com/study/course_registration/domain/registration/RegistrationDecisionSnapshot.java @@ -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> 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); } diff --git a/src/main/java/com/study/course_registration/domain/registration/UserProfile.java b/src/main/java/com/study/course_registration/domain/registration/UserProfile.java index baf5148..5039c8a 100644 --- a/src/main/java/com/study/course_registration/domain/registration/UserProfile.java +++ b/src/main/java/com/study/course_registration/domain/registration/UserProfile.java @@ -1,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"); } } diff --git a/src/main/java/com/study/course_registration/domain/validation/Require.java b/src/main/java/com/study/course_registration/domain/validation/Require.java new file mode 100644 index 0000000..a1f9ae8 --- /dev/null +++ b/src/main/java/com/study/course_registration/domain/validation/Require.java @@ -0,0 +1,40 @@ +package com.study.course_registration.domain.validation; + +import java.util.Objects; + +public final class Require { + private Require() { + } + + public static 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; + } +} diff --git a/src/main/java/com/study/course_registration/entity/Lesson.java b/src/main/java/com/study/course_registration/entity/Lesson.java index 06c3c4e..979f68b 100644 --- a/src/main/java/com/study/course_registration/entity/Lesson.java +++ b/src/main/java/com/study/course_registration/entity/Lesson.java @@ -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; } } diff --git a/src/main/java/com/study/course_registration/entity/LessonSchedule.java b/src/main/java/com/study/course_registration/entity/LessonSchedule.java index d5ad691..d7003d6 100644 --- a/src/main/java/com/study/course_registration/entity/LessonSchedule.java +++ b/src/main/java/com/study/course_registration/entity/LessonSchedule.java @@ -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"); } diff --git a/src/main/java/com/study/course_registration/entity/Professor.java b/src/main/java/com/study/course_registration/entity/Professor.java index 2663ce9..c09c838 100644 --- a/src/main/java/com/study/course_registration/entity/Professor.java +++ b/src/main/java/com/study/course_registration/entity/Professor.java @@ -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"); } } diff --git a/src/main/java/com/study/course_registration/entity/Semester.java b/src/main/java/com/study/course_registration/entity/Semester.java index 94f87ae..d8ecf28 100644 --- a/src/main/java/com/study/course_registration/entity/Semester.java +++ b/src/main/java/com/study/course_registration/entity/Semester.java @@ -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; - } } diff --git a/src/main/java/com/study/course_registration/entity/Subject.java b/src/main/java/com/study/course_registration/entity/Subject.java index 0493234..57bcd06 100644 --- a/src/main/java/com/study/course_registration/entity/Subject.java +++ b/src/main/java/com/study/course_registration/entity/Subject.java @@ -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; - } } diff --git a/src/main/java/com/study/course_registration/entity/User.java b/src/main/java/com/study/course_registration/entity/User.java index 49e6a0f..37d03ca 100644 --- a/src/main/java/com/study/course_registration/entity/User.java +++ b/src/main/java/com/study/course_registration/entity/User.java @@ -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"); } } diff --git a/src/main/java/com/study/course_registration/entity/UserLesson.java b/src/main/java/com/study/course_registration/entity/UserLesson.java index 0b1300e..de47ed1 100644 --- a/src/main/java/com/study/course_registration/entity/UserLesson.java +++ b/src/main/java/com/study/course_registration/entity/UserLesson.java @@ -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"); } } diff --git a/src/main/java/com/study/course_registration/infrastructure/persistence/idempotency/RegistrationIdempotencyEntity.java b/src/main/java/com/study/course_registration/infrastructure/persistence/idempotency/RegistrationIdempotencyEntity.java index 614a234..253c223 100644 --- a/src/main/java/com/study/course_registration/infrastructure/persistence/idempotency/RegistrationIdempotencyEntity.java +++ b/src/main/java/com/study/course_registration/infrastructure/persistence/idempotency/RegistrationIdempotencyEntity.java @@ -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; - } } diff --git a/src/test/java/com/study/course_registration/application/registration/RegisterCourseUseCaseTest.java b/src/test/java/com/study/course_registration/application/registration/RegisterCourseUseCaseTest.java index 544f0d0..2561aac 100644 --- a/src/test/java/com/study/course_registration/application/registration/RegisterCourseUseCaseTest.java +++ b/src/test/java/com/study/course_registration/application/registration/RegisterCourseUseCaseTest.java @@ -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); } diff --git a/src/test/java/com/study/course_registration/application/registration/idempotency/CleanupIdempotencyUseCaseTest.java b/src/test/java/com/study/course_registration/application/registration/idempotency/CleanupIdempotencyUseCaseTest.java index b8407d1..1f9ba46 100644 --- a/src/test/java/com/study/course_registration/application/registration/idempotency/CleanupIdempotencyUseCaseTest.java +++ b/src/test/java/com/study/course_registration/application/registration/idempotency/CleanupIdempotencyUseCaseTest.java @@ -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); } } diff --git a/src/test/java/com/study/course_registration/architecture/SourceStyleTest.java b/src/test/java/com/study/course_registration/architecture/SourceStyleTest.java index 7188ef7..f7ea72b 100644 --- a/src/test/java/com/study/course_registration/architecture/SourceStyleTest.java +++ b/src/test/java/com/study/course_registration/architecture/SourceStyleTest.java @@ -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 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()) { diff --git a/src/test/java/com/study/course_registration/domain/registration/DomainValidationContractTest.java b/src/test/java/com/study/course_registration/domain/registration/DomainValidationContractTest.java new file mode 100644 index 0000000..37c2cb2 --- /dev/null +++ b/src/test/java/com/study/course_registration/domain/registration/DomainValidationContractTest.java @@ -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); + } +} diff --git a/src/test/java/com/study/course_registration/domain/validation/RequireTest.java b/src/test/java/com/study/course_registration/domain/validation/RequireTest.java new file mode 100644 index 0000000..f244c29 --- /dev/null +++ b/src/test/java/com/study/course_registration/domain/validation/RequireTest.java @@ -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); + } +} diff --git a/src/test/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationExecutionScopeLoaderTest.java b/src/test/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationExecutionScopeLoaderTest.java index d66b99b..f54fa94 100644 --- a/src/test/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationExecutionScopeLoaderTest.java +++ b/src/test/java/com/study/course_registration/infrastructure/persistence/JpaRegistrationExecutionScopeLoaderTest.java @@ -3,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"); } } diff --git a/src/test/java/com/study/course_registration/infrastructure/scheduling/IdempotencyRetentionJobTest.java b/src/test/java/com/study/course_registration/infrastructure/scheduling/IdempotencyRetentionJobTest.java index f75f6b2..a89e469 100644 --- a/src/test/java/com/study/course_registration/infrastructure/scheduling/IdempotencyRetentionJobTest.java +++ b/src/test/java/com/study/course_registration/infrastructure/scheduling/IdempotencyRetentionJobTest.java @@ -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.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.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(); } }