refactor: 코드 품질 개선 및 테스트 안정성 강화

- datetime.now() → now_utc() 유틸리티로 통일 (repository, service)
- 프로덕션 환경 보안 설정 검증 로직 추가 (config.py)
- 벌크 동기화 예외 처리 및 로깅 개선 (service.py)
- 테스트용 user_id_factory fixture 추가로 PK 충돌 방지
- 벌크 동기화 DB 반영 검증 테스트 추가
- 벌크 동기화 예외 발생 시 로그/전파 테스트 추가
- 프로덕션 환경 설정 검증 단위 테스트 추가

Author: wonjun0120

app/core/config.py

@@ -1,7 +1,7 @@
 from functools import lru_cache
 from typing import List
 
-from pydantic import field_validator
+from pydantic import field_validator, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
@@ -59,6 +59,39 @@ def parse_cors_origins(cls, v):
                 return [origin.strip() for origin in v.split(",")]
         return v
 
+    @model_validator(mode="after")
+    def validate_production_settings(self) -> "Settings":
+        """프로덕션 환경에서 보안 설정 검증"""
+        if not self.is_production:
+            return self
+
+        # Internal API Key 검증
+        if self.internal_api_key == "your-internal-api-key-here":
+            raise ValueError(
+                "Production requires valid INTERNAL_API_KEY. "
+                "Set it via environment variable."
+            )
+
+        if len(self.internal_api_key) < 32:
+            raise ValueError(
+                "INTERNAL_API_KEY must be at least 32 characters long "
+                "for security."
+            )
+
+        # Secret Key 검증 (JWT 구현 시)
+        if self.secret_key == "your-secret-key-here":
+            raise ValueError(
+                "Production requires valid SECRET_KEY. "
+                "Set it via environment variable."
+            )
+
+        if len(self.secret_key) < 32:
+            raise ValueError(
+                "SECRET_KEY must be at least 32 characters long for security."
+            )
+
+        return self
+
     @property
     def is_development(self) -> bool:
         return self.app_env == "development"

app/domains/users/repository.py

@@ -3,12 +3,12 @@
 Spring Boot 사용자 동기화를 위한 데이터 접근 계층입니다.
 """
 
-from datetime import datetime
 from typing import Optional, Sequence, cast
 
 from sqlalchemy import func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.core.utils.datetime import now_utc
 from app.domains.users.models import User
 
 
@@ -120,7 +120,7 @@ async def soft_delete(self, user: User) -> User:
         Returns:
             삭제된 사용자 객체
         """
-        user.deleted_at = datetime.now()
+        user.deleted_at = now_utc()
         await self.session.flush()
         await self.session.refresh(user)
         return user

app/domains/users/service.py

@@ -3,12 +3,11 @@
 Spring Boot 사용자 동기화를 위한 비즈니스 로직 계층입니다.
 """
 
-from datetime import datetime
-
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core.logging import get_logger
 from app.core.middlewares.context import get_request_id
+from app.core.utils.datetime import now_utc
 from app.domains.users.exceptions import UserNotFoundException
 from app.domains.users.models import User
 from app.domains.users.repository import UserRepository
@@ -87,7 +86,7 @@ async def upsert_user(self, user_data: UserSync) -> User:
             if existing.deleted_at:
                 existing.deleted_at = None  # 복구
 
-            existing.last_sync_at = datetime.now()
+            existing.last_sync_at = now_utc()
             user = await self.repository.update(existing)
 
             logger.info(
@@ -101,7 +100,7 @@ async def upsert_user(self, user_data: UserSync) -> User:
             return user
         else:
             # 생성
-            user = User(id=user_data.id, last_sync_at=datetime.now())
+            user = User(id=user_data.id, last_sync_at=now_utc())
             created_user = await self.repository.create(user)
 
             logger.info(
@@ -131,42 +130,43 @@ async def bulk_upsert_users(
         restored = 0
 
         for user_data in users:
-            existing = await self.repository.get_by_id(
-                user_data.id, include_deleted=True
-            )
-
-            if existing:
-                was_deleted = existing.deleted_at is not None
-                if was_deleted:
-                    existing.deleted_at = None
-                    restored += 1
+            try:
+                existing = await self.repository.get_by_id(
+                    user_data.id, include_deleted=True
+                )
+
+                if existing:
+                    was_deleted = existing.deleted_at is not None
+                    if was_deleted:
+                        existing.deleted_at = None
+                        restored += 1
+                    else:
+                        updated += 1
+
+                    existing.last_sync_at = now_utc()
+                    await self.repository.update(existing)
                 else:
-                    updated += 1
-
-                existing.last_sync_at = datetime.now()
-                await self.repository.update(existing)
-            else:
-                user = User(id=user_data.id, last_sync_at=datetime.now())
-                await self.repository.create(user)
-                created += 1
-
-        result = BulkSyncResponse(
-            total=total, created=created, updated=updated, restored=restored
-        )
-
-        logger.info(
-            "Bulk sync completed",
-            extra={
-                "request_id": get_request_id(),
-                "sync_total": total,
-                "sync_created": created,
-                "sync_updated": updated,
-                "sync_restored": restored,
-            },
+                    user = User(id=user_data.id, last_sync_at=now_utc())
+                    await self.repository.create(user)
+                    created += 1
+
+            except Exception:
+                logger.exception(
+                    "Failed to sync user",
+                    extra={
+                        "request_id": get_request_id(),
+                        "user_id": getattr(user_data, "id", None),
+                    },
+                )
+                raise
+
+        return BulkSyncResponse(
+            total=total,
+            created=created,
+            updated=updated,
+            restored=restored,
         )
 
-        return result
-
     async def delete_user(self, user_id: int) -> None:
         """사용자 Soft Delete
 

tests/conftest.py

@@ -1,5 +1,6 @@
 """테스트 설정"""
 
+import itertools
 from typing import Generator
 
 import pytest
@@ -11,9 +12,27 @@
 
 from app.core.config import settings
 from app.core.database import Base, get_db
+from app.core.utils.datetime import now_utc
 from app.main import app
 
 
+@pytest.fixture(scope="session")
+def user_id_factory():
+    """
+    테스트마다 겹치지 않는 PK를 만들기 위한 ID 팩토리.
+    UTC 기준 현재 타임스탬프(ms)를 시작값으로 사용
+    """
+    start = int(now_utc().timestamp())
+    counter = itertools.count(start=start)
+
+    def _factory(n: int = 1):
+        if n == 1:
+            return next(counter)
+        return [next(counter) for _ in range(n)]
+
+    return _factory
+
+
 @pytest.fixture(scope="session")
 def postgres_container() -> Generator[PostgresContainer, None, None]:
     """PostgreSQL 테스트 컨테이너"""

tests/e2e/test_scenarios.py

@@ -74,7 +74,9 @@ class TestUserSyncScenarios:
     """사용자 동기화 E2E 시나리오 (DB 필요)"""
 
     @pytest.mark.asyncio
-    async def test_user_sync_full_lifecycle(self, client, api_key_header):
+    async def test_user_sync_full_lifecycle(
+        self, client, api_key_header, user_id_factory
+    ):
         """사용자 동기화 전체 생명주기 테스트
 
         시나리오:
@@ -86,7 +88,7 @@ async def test_user_sync_full_lifecycle(self, client, api_key_header):
         6. 복구된 사용자 조회 및 검증
         """
         # 1. 새 사용자 동기화
-        user_id = 10001
+        user_id = user_id_factory()
         response = await client.post(
             "/api/v1/users",
             json={"id": user_id},
@@ -140,7 +142,9 @@ async def test_user_sync_full_lifecycle(self, client, api_key_header):
         assert response.json()["data"]["deleted_at"] is None
 
     @pytest.mark.asyncio
-    async def test_bulk_sync_scenario(self, client, api_key_header):
+    async def test_bulk_sync_scenario(
+        self, client, api_key_header, user_id_factory
+    ):
         """벌크 동기화 시나리오 테스트
 
         시나리오:
@@ -149,7 +153,7 @@ async def test_bulk_sync_scenario(self, client, api_key_header):
         3. 사용자 목록 조회로 확인
         """
         # 1. 100명 사용자 생성
-        user_ids = list(range(20001, 20101))
+        user_ids = user_id_factory(n=100)
         users = [{"id": uid} for uid in user_ids]
 
         response = await client.post(

tests/integration/test_users_api.py

@@ -143,6 +143,34 @@ async def test_bulk_sync_valid_request_format(
 
         assert response.status_code == 201
 
+    @pytest.mark.asyncio
+    async def test_bulk_sync_persists_users(self, client, api_key_header):
+        """벌크 동기화 후 실제로 DB에 반영되는지 확인"""
+        users = [{"id": 101}, {"id": 102}, {"id": 103}]
+
+        # When
+        response = await client.post(
+            "/api/v1/users/bulk", json={"users": users}, headers=api_key_header
+        )
+
+        # Then
+        assert response.status_code == 201
+        data = response.json()["data"]
+        assert data["created"] == 3
+        assert data["total"] == 3
+
+        # 실제 조회로 검증
+        list_response = await client.get(
+            "/api/v1/users?page=1&size=100",
+            headers=api_key_header,
+        )
+        assert list_response.status_code == 200
+
+        returned_ids = {u["id"] for u in list_response.json()["data"]}
+
+        for uid in [101, 102, 103]:
+            assert uid in returned_ids
+
 
 class TestUserDeleteAPI:
     """사용자 삭제 API 테스트"""