refactor: 공통 로직 분리
This commit is contained in:
+14
-22
@@ -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);
|
||||
}
|
||||
|
||||
+8
-8
@@ -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");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+12
-24
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
+11
-8
@@ -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);
|
||||
}
|
||||
|
||||
+6
-6
@@ -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()) {
|
||||
|
||||
+37
@@ -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);
|
||||
}
|
||||
}
|
||||
+7
-7
@@ -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");
|
||||
}
|
||||
}
|
||||
|
||||
+11
-9
@@ -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();
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user