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
@@ -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();
}
}