[BOM-1163] refactor: 테스트 코드 개선

backend/bom-bom-server/build.gradle.kts

@@ -61,6 +61,7 @@ dependencies {
 
     // test
     testImplementation("org.springframework.boot:spring-boot-starter-test")
+    testImplementation("io.rest-assured:spring-mock-mvc")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
     testImplementation("org.testcontainers:testcontainers")
     testImplementation("org.testcontainers:testcontainers-mysql")
@@ -109,8 +110,47 @@ tasks.named<Delete>("clean") {
     delete(layout.buildDirectory.dir("generated"))
 }
 
+val reuseTestcontainers = providers.gradleProperty("reuseTestcontainers")
+    .map(String::toBoolean)
+    .orElse(false)
+
+fun Test.configureIntegrationExecution() {
+    maxParallelForks = 2
+
+    if (reuseTestcontainers.get()) {
+        environment("TESTCONTAINERS_REUSE_ENABLE", "true")
+        systemProperty("bombom.testcontainers.reuse", "true")
+    }
+}
+
 tasks.test {
     useJUnitPlatform()
+    configureIntegrationExecution()
+}
+
+val testSourceSet = sourceSets.named("test")
+
+tasks.register<Test>("unitTest") {
+    group = "verification"
+    description = "Spring Context 없이 실행되는 단위 테스트만 실행합니다."
+    testClassesDirs = testSourceSet.get().output.classesDirs
+    classpath = testSourceSet.get().runtimeClasspath
+    useJUnitPlatform {
+        excludeTags("integration")
+    }
+    maxParallelForks = 2
+}
+
+tasks.register<Test>("integrationTest") {
+    group = "verification"
+    description = "Spring Context 또는 DB를 사용하는 통합 테스트만 실행합니다."
+    testClassesDirs = testSourceSet.get().output.classesDirs
+    classpath = testSourceSet.get().runtimeClasspath
+    useJUnitPlatform {
+        includeTags("integration")
+    }
+    configureIntegrationExecution()
+    shouldRunAfter(tasks.named("unitTest"))
 }
 
 apply(from = "$projectDir/gradle/openapi-generator.gradle")

backend/bom-bom-server/gradle/openapi-generated-format.gradle

@@ -1,4 +1,5 @@
 def generatedOpenApiJavaDir = layout.projectDirectory.dir("generated/openapi")
+def openApiGenerationFingerprintFile = generatedOpenApiJavaDir.file(".generation-fingerprint")
 def lineSeparator = System.lineSeparator()
 def recordPattern = ~/(?s)public record (\w+)\(\R(.*?)\R\) \{\R/
 
@@ -117,7 +118,10 @@ def normalizeRecordComponentBlankLines = { File file ->
 
 def removeResponseContainerElementValidation = { File file ->
     String text = file.getText("UTF-8")
-    file.setText(text.replaceAll(/List<@Valid /, "List<"), "UTF-8")
+    String normalized = text.replaceAll(/List<@Valid /, "List<")
+    if (normalized != text) {
+        file.setText(normalized, "UTF-8")
+    }
 }
 
 def formatResponseModel = { File file ->
@@ -198,7 +202,19 @@ tasks.named("spotlessOpenApiModelsApply") {
     dependsOn("spotlessOpenApiModels")
 }
 
+[
+    "addOpenApiResponseFactories",
+    "spotlessJava",
+    "spotlessJavaApply",
+    "spotlessOpenApiModels",
+    "spotlessOpenApiModelsApply",
+].each { taskName ->
+    tasks.named(taskName) {
+        onlyIf { !openApiGenerationFingerprintFile.asFile.exists() }
+    }
+}
+
 // 컴파일 전에는 생성 코드 포맷까지 끝난 상태를 보장한다.
 tasks.named("compileJava") {
-    dependsOn("spotlessJavaApply", "spotlessOpenApiModelsApply")
+    dependsOn("writeOpenApiGenerationFingerprint")
 }

backend/bom-bom-server/gradle/openapi-generator.gradle

@@ -53,6 +53,28 @@ def openApiDomainGroups = [
     ],
 ]
 
+def openApiGenerationFingerprintFile = generatedOpenApiDir.file(".generation-fingerprint")
+def openApiGenerationInputFiles = files(
+    openApiSpecFile,
+    fileTree("src/main/resources/openapi-templates"),
+    layout.projectDirectory.file("gradle/openapi-generator.gradle"),
+    layout.projectDirectory.file("gradle/openapi-generated-format.gradle"),
+)
+def calculateOpenApiGenerationFingerprint = {
+    def digest = java.security.MessageDigest.getInstance("SHA-256")
+    openApiGenerationInputFiles.files
+        .findAll(File::exists)
+        .sort { left, right -> left.absolutePath <=> right.absolutePath }
+        .each { input ->
+            digest.update(input.absolutePath.getBytes("UTF-8"))
+            digest.update(input.bytes)
+        }
+    digest.update(openApiDomainGroups.toString().getBytes("UTF-8"))
+    digest.update(openApiConfigOptions.toString().getBytes("UTF-8"))
+    digest.update(openApiGlobalProperties.toString().getBytes("UTF-8"))
+    return digest.digest().encodeHex().toString()
+}
+
 // submodule이 초기화되지 않은 상태에서 빌드가 진행되지 않도록 막는다.
 tasks.register("verifyOpenApiSpec") {
     doLast {
@@ -69,10 +91,28 @@ tasks.register("cleanGeneratedOpenApi", Delete) {
     delete(generatedOpenApiDir)
 }
 
+tasks.register("prepareOpenApiGeneration") {
+    dependsOn("verifyOpenApiSpec")
+
+    doLast {
+        String expectedFingerprint = calculateOpenApiGenerationFingerprint()
+        File fingerprintFile = openApiGenerationFingerprintFile.asFile
+        boolean generatedSourcesExist = !fileTree(generatedOpenApiDir) {
+            include("**/*.java")
+        }.isEmpty()
+        boolean fingerprintMatches = fingerprintFile.exists() &&
+            fingerprintFile.getText("UTF-8") == expectedFingerprint
+
+        if (!generatedSourcesExist || !fingerprintMatches) {
+            delete(generatedOpenApiDir)
+        }
+    }
+}
+
 def openApiDomainGenerateTasks = openApiDomainGroups.collect { domain ->
     tasks.register("openApiGenerate${domain.name}", openApiGeneratorTaskClass) {
-        dependsOn("verifyOpenApiSpec")
-        mustRunAfter("cleanGeneratedOpenApi")
+        dependsOn("prepareOpenApiGeneration")
+        onlyIf { !openApiGenerationFingerprintFile.asFile.exists() }
         generatorName.set("spring")
         inputSpec.set(openApiSpecFile.asFile.absolutePath)
         outputDir.set(generatedOpenApiDir.asFile.absolutePath)
@@ -97,11 +137,33 @@ def openApiDomainGenerateTasks = openApiDomainGroups.collect { domain ->
 // OpenAPI 스펙으로부터 Spring 인터페이스와 모델을 도메인별 패키지에 생성한다.
 tasks.named("openApiGenerate") {
     dependsOn("verifyOpenApiSpec")
-    dependsOn("cleanGeneratedOpenApi")
     dependsOn(openApiDomainGenerateTasks)
     onlyIf { false }
 }
 
+tasks.register("regenerateOpenApi") {
+    group = "openapi tools"
+    description = "생성 결과를 삭제하고 OpenAPI 코드를 다시 생성합니다."
+    dependsOn("cleanGeneratedOpenApi", "writeOpenApiGenerationFingerprint")
+}
+openApiDomainGenerateTasks.each { generatorTask ->
+    generatorTask.configure {
+        mustRunAfter("cleanGeneratedOpenApi")
+    }
+}
+
+tasks.register("writeOpenApiGenerationFingerprint") {
+    dependsOn("spotlessJavaApply", "spotlessOpenApiModelsApply")
+    inputs.files(openApiGenerationInputFiles)
+    outputs.file(openApiGenerationFingerprintFile)
+
+    doLast {
+        File fingerprintFile = openApiGenerationFingerprintFile.asFile
+        fingerprintFile.parentFile.mkdirs()
+        fingerprintFile.setText(calculateOpenApiGenerationFingerprint(), "UTF-8")
+    }
+}
+
 sourceSets {
     main {
         java {

backend/bom-bom-server/src/main/java/me/bombom/api/v1/common/exception/GlobalExceptionHandler.java

@@ -2,12 +2,12 @@
 
 import jakarta.validation.ConstraintViolationException;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.core.convert.ConversionFailedException;
 import org.springframework.http.ResponseEntity;
 import org.springframework.http.converter.HttpMessageNotReadableException;
 import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
-import org.springframework.core.convert.ConversionFailedException;
 import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
 import org.springframework.web.servlet.resource.NoResourceFoundException;
 
@@ -18,9 +18,9 @@ public class GlobalExceptionHandler {
     @ExceptionHandler(CIllegalArgumentException.class)
     public ResponseEntity<ErrorResponse> handleIllegalArgumentException(CIllegalArgumentException e) {
         if (!e.getContext().isEmpty()) {
-            log.info("IllegalArgumentException: {} - Context: {}", e.getMessage(), e.getContext(), e);
+            log.info("IllegalArgumentException: {} - Context: {}", e.getMessage(), e.getContext());
         } else {
-            log.info("IllegalArgumentException: ", e);
+            log.info("IllegalArgumentException: {}", e.getMessage());
         }
         return ResponseEntity.status(e.getHttpStatus())
                 .body(ErrorResponse.from(e.getErrorDetail()));
@@ -32,7 +32,7 @@ public ResponseEntity<ErrorResponse> handleConversionFailedException(ConversionF
         if (cause instanceof CIllegalArgumentException illegalArg) {
             return handleIllegalArgumentException(illegalArg);
         }
-        log.info("Conversion failed: ", e);
+        log.info("Conversion failed: {}", e.getMessage());
         return ResponseEntity.status(ErrorDetail.INVALID_REQUEST_PARAMETER_VALIDATION.getStatus())
                 .body(ErrorResponse.from(ErrorDetail.INVALID_REQUEST_PARAMETER_VALIDATION));
     }
@@ -48,32 +48,32 @@ public ResponseEntity<ErrorResponse> handleMethodArgumentTypeMismatchException(
         if (cause instanceof CIllegalArgumentException illegalArg) {
             return handleIllegalArgumentException(illegalArg);
         }
-        log.info("Method argument type mismatch: ", e);
+        log.info("Method argument type mismatch: name={}, value={}", e.getName(), e.getValue());
         return ResponseEntity.status(ErrorDetail.INVALID_REQUEST_PARAMETER_VALIDATION.getStatus())
                 .body(ErrorResponse.from(ErrorDetail.INVALID_REQUEST_PARAMETER_VALIDATION));
     }
 
     @ExceptionHandler(UnauthorizedException.class)
     public ResponseEntity<ErrorResponse> handleUnauthorizedException(UnauthorizedException e) {
         if (!e.getContext().isEmpty()) {
-            log.warn("UnauthorizedException: {} - Context: {}", e.getMessage(), e.getContext(), e);
+            log.warn("UnauthorizedException: {} - Context: {}", e.getMessage(), e.getContext());
         } else {
-            log.warn("UnauthorizedException: ", e);
+            log.warn("UnauthorizedException: {}", e.getMessage());
         }
         return ResponseEntity.status(e.getHttpStatus())
                 .body(ErrorResponse.from(e.getErrorDetail()));
     }
 
     @ExceptionHandler(MethodArgumentNotValidException.class)
-    public ResponseEntity<ErrorResponse> handleMethodArgumentNotValidException(MethodArgumentNotValidException e){
-        log.info("Validation failed: ", e);
+    public ResponseEntity<ErrorResponse> handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
+        log.info("Validation failed: {}", e.getBindingResult().getFieldErrors());
         return ResponseEntity.status(ErrorDetail.INVALID_REQUEST_BODY_VALIDATION.getStatus())
                 .body(ErrorResponse.from(ErrorDetail.INVALID_REQUEST_BODY_VALIDATION));
     }
 
     @ExceptionHandler(ConstraintViolationException.class)
-    public ResponseEntity<ErrorResponse> handleConstraintViolationException(ConstraintViolationException e){
-        log.info("Constraint violation: ", e);
+    public ResponseEntity<ErrorResponse> handleConstraintViolationException(ConstraintViolationException e) {
+        log.info("Constraint violation: {}", e.getConstraintViolations());
         return ResponseEntity.status(ErrorDetail.INVALID_REQUEST_PARAMETER_VALIDATION.getStatus())
                 .body(ErrorResponse.from(ErrorDetail.INVALID_REQUEST_PARAMETER_VALIDATION));
     }
@@ -91,14 +91,14 @@ public ResponseEntity<ErrorResponse> handleCServerErrorException(CServerErrorExc
 
     @ExceptionHandler(NoResourceFoundException.class)
     public ResponseEntity<ErrorResponse> handleNoResourceFoundException(NoResourceFoundException e) {
-        log.warn("No resource found: ", e);
+        log.warn("No resource found: {}", e.getResourcePath());
         return ResponseEntity.status(ErrorDetail.ENTITY_NOT_FOUND.getStatus())
                 .body(ErrorResponse.from(ErrorDetail.ENTITY_NOT_FOUND));
     }
 
     @ExceptionHandler(HttpMessageNotReadableException.class)
     public ResponseEntity<ErrorResponse> handleNotReadable(HttpMessageNotReadableException e) {
-        log.info("Request body parse error: ", e);
+        log.info("Request body parse error: {}", e.getMessage());
         return ResponseEntity.status(ErrorDetail.INVALID_REQUEST_PARAMETER_VALIDATION.getStatus())
                 .body(ErrorResponse.from(ErrorDetail.INVALID_REQUEST_PARAMETER_VALIDATION));
     }

backend/bom-bom-server/src/main/java/me/bombom/api/v1/reading/scheduler/ReadingScheduler.java

@@ -1,5 +1,6 @@
 package me.bombom.api.v1.reading.scheduler;
 
+import java.time.Clock;
 import java.time.LocalDateTime;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -21,6 +22,7 @@ public class ReadingScheduler {
 
     private final ReadingService readingService;
     private final ContinueReadingShieldService continueReadingShieldService;
+    private final Clock clock;
 
     @Scheduled(cron = DAILY_CRON, zone = TIME_ZONE)
     @SchedulerLock(name = "daily_reset_reading_count", lockAtLeastFor = "PT4S", lockAtMostFor = "PT9S")
@@ -87,7 +89,7 @@ public void tenMinutelyCalculateContinueReadingRankingSnapshot() {
      * - 00:10분부터: 업데이트 (10분간 데이터 쌓임)
      */
     private boolean shouldSkipRankingUpdate() {
-        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime now = LocalDateTime.now(clock);
 
         // 매월 1일이고 시간이 00:00~00:09분 사이인 경우 스킵
         if (now.getDayOfMonth() == 1) {