fix: 2026-10-15 코드 검토 F01~F10 — 수집 실패 전파·트랜잭션 경계·저장 실패·공지 버전/확인 조건·테스트 체계

- F01 쿠팡: HTTP 200 비JSON·data 목록 없음은 수집 실패(기간 교체 안 함), 정상 빈 목록과 구분
- F02 회의록 [적용]: 업무 INSERT 와 줄 연결을 한 연결·한 트랜잭션(_insert_task), 확인은 잠그기 전·알림/메일은 커밋 뒤, 줄 바뀜 409
- F03 업무 등록 표: persist 실패 전파, 미저장이면 [적용] 중단, 초안 유지·다시 저장·이탈 경고
- F04 인증정보 변경 시 내부 토큰 삭제 + 네이버·토스 토큰을 발급 인증정보 지문(SHA-256)에 묶음, GS샵 방식 캐시도 키 지문 기준
- F05 쪽 수 상한·커서 반복 = 실패(쿠팡은 구간을 하루까지 나눠 재시도), 네이버·카카오·토스·GS샵 동일 기준
- F06 [중지] 확인과 저장 시작을 같은 잠금(begin_saving), 저장 시작 뒤 중지 불가
- F07/F08 긴급 공지: 내용 version·고친 공지 다시 그리기·확인에 version(409), 확인은 행 잠금 트랜잭션에서 수신자·표시 시각·취소 검증
- F09 쇼핑몰 연결 테스트도 clear 처리·저장 안 한 시험은 상태 유지(광고 테스트와 같은 계약)
- F10 DB 테스트 skip·가짜 app.main/time.sleep 파일 범위 fixture, 오래된 기대값 갱신, pytest.ini·requirements-dev·tests/js/package.json·docs/TESTING.md
- 결과·후속 과제: docs/CODE_REVIEW_2026-10-15_RESULT.md (마이그레이션·환경변수 변경 없음)

Python 440 passed/63 skipped(DB 없음), 503 passed(로컬 PostgreSQL), jsdom 7종·Edge 6종 통과

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-15 18:41:42 +09:00
parent edd5a97a9b
commit c7cc94a09c
51 changed files with 1536 additions and 222 deletions
+10
View File
@@ -131,6 +131,16 @@ class SaleEvent:
raise ValueError("취소/반품 금액은 음수(또는 0)여야 합니다.")
def credential_fingerprint(credentials: Any, keys: Iterable[str]) -> str:
"""토큰을 발급한 인증정보 묶음의 지문(SHA-256 16진수) — 원문은 남기지 않는다(2026-10-15 검토 F04).
저장된 토큰은 이 지문이 지금 인증정보(연결 테스트의 새 입력값 포함)와 같을 때만 다시 쓴다 —
계정·키를 바꾸면 이전 계정 토큰을 쓰지 않고, 같은 값을 다시 저장하면 토큰을 새로 받지 않는다."""
import hashlib # noqa: WPS433
raw = "\x1f".join(f"{k}={(credentials.get(k) or '').strip()}" for k in keys)
return hashlib.sha256(raw.encode("utf-8")).hexdigest()
class CredentialAccessor(Protocol):
def get(self, key: str) -> str: ...
+46 -5
View File
@@ -70,6 +70,12 @@ KST_OFFSET = timedelta(hours=9)
class GatewayTimeout(ApiError):
"""쿠팡 서버가 시간 안에 답하지 못함(502·503·504·응답 시간 초과) — 조회 기간을 줄이면 대개 풀린다."""
class TooManyPages(ApiError):
"""한 번 조회가 끝까지 받았는지 확인되지 않음(쪽 수 상한·커서 반복) — 조회 기간을 줄여 다시 부른다(F05)."""
# 원본 확인·저장에서 통째로 빼는 항목(구매자·수령자·통관 정보·배송 메모·직접 입력 항목)
PERSONAL_KEYS = frozenset({"orderer", "receiver", "overseaShippingInfoDto", "parcelPrintMessage"})
PERSONAL_ITEM_KEYS = frozenset({"etcInfoHeader", "etcInfoValue", "etcInfoValues"})
@@ -300,6 +306,11 @@ class CoupangAdapter(MarketplaceAdapter):
try:
body = res.json()
except ValueError:
if res.status_code < 400:
# HTTP 200 이어도 JSON 이 아니면(점검·프록시 안내 페이지 등) 수집 실패 — 빈 목록으로 보면 기간 교체 때
# 그 기간 매출이 지워진다(2026-10-15 검토 F01). 오류 응답(4xx·5xx)은 아래에서 글자로 안내한다.
raise ApiError(f"쿠팡 {what} 응답이 JSON 이 아닙니다(HTTP {res.status_code}) — 점검 중일 수 있어 "
"저장하지 않았습니다. 잠시 뒤 다시 시도하세요.") from None
body = {}
if not isinstance(body, dict):
body = {"data": body}
@@ -321,18 +332,38 @@ class CoupangAdapter(MarketplaceAdapter):
return body
raise ApiError(f"쿠팡 {what} 호출 제한(429)이 계속됩니다. 잠시 뒤 다시 시도하세요.")
@staticmethod
def _page_rows(body: dict[str, Any], what: str) -> list[dict[str, Any]]:
"""한 쪽의 주문 목록 — `data` 가 목록이어야 한다. 목록이 아니면 빈 목록(주문 0건)과 구분해 실패로(F01):
`data` 가 없거나 다른 형식이면 오류, `data: null` 은 성공 표시(code 200·OK/SUCCESS)가 함께 있을 때만 빈 목록."""
data = body.get("data")
if isinstance(data, list):
return [r for r in data if isinstance(r, dict)]
code, msg = body.get("code"), str(body.get("message") or "").strip().upper()
if "data" in body and data is None and (code in (200, "200") or msg in ("OK", "SUCCESS")):
return []
raise ApiError(f"쿠팡 {what} 응답 형식이 예상과 다릅니다(주문 목록 data 없음) — 저장하지 않았습니다. 잠시 뒤 다시 시도하세요.")
def _pages(self, ctx: AdapterContext, path: str, params: dict[str, Any], *, rg: bool = False) -> list[dict[str, Any]]:
"""nextToken 으로 끝까지 받는다. 끝(다음 쪽 없음)을 확인하지 못하면 TooManyPages — 일부만 받은 목록으로
기간을 교체하지 않게(2026-10-15 검토 F05). 부르는 쪽이 기간을 나눠 다시 부른다.
- MAX_PAGES 를 다 써도 다음 쪽이 남음 · 같은 nextToken 이 다시 옴(커서 반복) → TooManyPages
- 빈 쪽인데 다음 쪽이 있으면 따라간다(예전엔 거기서 끝난 것으로 봤다)"""
what = "로켓그로스 주문" if rg else "발주서"
out: list[dict[str, Any]] = []
token: str | None = None
seen: set[str] = set()
for _ in range(MAX_PAGES):
body = self._get(ctx, path, {**params, "nextToken": token} if token else params, rg=rg)
rows = [r for r in (body.get("data") or []) if isinstance(r, dict)] if isinstance(body.get("data"), list) else []
out.extend(rows)
out.extend(self._page_rows(body, what))
nxt = str(body.get("nextToken") or "").strip()
if not nxt or not rows or nxt == token:
break
if not nxt:
return out # 마지막 쪽 확인
if nxt in seen:
raise TooManyPages(f"쿠팡 {what} 다음 쪽 표시가 반복돼 끝까지 받았는지 확인할 수 없습니다 — 저장하지 않았습니다.")
seen.add(nxt)
token = nxt
return out
raise TooManyPages(f"쿠팡 {what} 한 번 조회가 {MAX_PAGES}쪽을 넘었습니다 — 일부만 받은 채 저장하지 않았습니다.")
def _seller_orders(self, ctx: AdapterContext, start: date, end: date) -> list[dict[str, Any]]:
"""판매자배송 발주서 — 주문일 [start-1, end] 를 31일씩 × 상태 6개. 결제일 필터는 seller_lines 가.
@@ -362,6 +393,11 @@ class CoupangAdapter(MarketplaceAdapter):
continue
raise ApiError(f"{exc.message} [주문일 {d.isoformat()} 하루도 시간 초과, 상태 {st}] "
"— 잠시 뒤 다시 시도하세요.") from None
except TooManyPages as exc: # 끝까지 못 받음 — 구간을 반으로(하루까지), 하루도 넘치면 실패
if size_by_status[st] > 1:
size_by_status[st] = max(1, size_by_status[st] // 2)
continue
raise ApiError(f"{exc.message} [주문일 {d.isoformat()} 하루, 상태 {st}]") from None
except ApiError as exc: # 긴 기간을 나눠 부를 때 어느 구간에서 막혔는지 알 수 있게
raise ApiError(f"{exc.message} [주문일 {d.isoformat()}~{e.isoformat()}, 상태 {st}]") from None
rows.extend(part)
@@ -391,6 +427,11 @@ class CoupangAdapter(MarketplaceAdapter):
continue
raise ApiError(f"{exc.message} [로켓그로스 결제일 {d.isoformat()} 하루도 시간 초과] "
"— 잠시 뒤 다시 시도하세요.") from None
except TooManyPages as exc: # 끝까지 못 받음 — 구간을 반으로(하루까지), 하루도 넘치면 실패
if size > 1:
size = max(1, size // 2)
continue
raise ApiError(f"{exc.message} [로켓그로스 결제일 {d.isoformat()} 하루]") from None
except ApiError as exc:
raise ApiError(f"{exc.message} [로켓그로스 결제일 {d.isoformat()}~{e.isoformat()}]") from None
rows.extend(part)
+17 -7
View File
@@ -36,6 +36,7 @@ from datetime import date, datetime, timedelta
from typing import Any, Iterable
from .base import (
credential_fingerprint,
AdapterContext,
AdapterError,
ApiError,
@@ -143,7 +144,8 @@ class GsshopAdapter(MarketplaceAdapter):
"운영 KEY(오른쪽 [복사] 버튼)를 입력합니다. 개발 KEY 가 아니라 운영 KEY 입니다.")
def __init__(self) -> None:
self._mode: dict[str, tuple[str, str]] = {} # 협력사코드 → 통과한 (키 변형, 암호화 모드)
# (협력사코드·운영 KEY 지문) → 통과한 (키 변형, 암호화 모드). 키를 바꾸면 예전 방식을 쓰지 않는다(검토 F04)
self._mode: dict[str, tuple[str, str]] = {}
def credential_fields(self) -> list[CredentialField]:
# 키 이름(vendor_code·api_key)은 처음 만든 입력칸 그대로 — 이미 저장한 값을 다시 넣지 않아도 되게.
@@ -191,7 +193,8 @@ class GsshopAdapter(MarketplaceAdapter):
def _get(self, ctx: AdapterContext, path: str, params: dict[str, Any]) -> dict[str, Any]:
"""토큰 만드는 법(키 변형 × 암호화 모드)을 모르면 순서대로 시도 — 통과한 조합을 기억한다."""
sup, key = self._creds(ctx)
known = self._mode.get(sup)
mode_key = self._mode_key(ctx)
known = self._mode.get(mode_key)
if known:
return self._call(ctx, path, params, known)
tries = [(v, m) for v, _ in key_variants(key) for m in TOKEN_MODES]
@@ -202,7 +205,7 @@ class GsshopAdapter(MarketplaceAdapter):
except AuthFailed as exc:
last = exc
continue
self._mode[sup] = how
self._mode[mode_key] = how
return body
raise AuthFailed(f"{last.message if last else 'GS샵 인증 실패'} — 토큰 만드는 방식 {len(tries)}가지 모두 거부. "
"협력사코드·운영 KEY 가 맞는지, 서버 시각이 정확한지 확인하세요.")
@@ -220,6 +223,9 @@ class GsshopAdapter(MarketplaceAdapter):
out.extend(rows)
if not body.get("hasMorePage") or not rows:
break
else: # 쪽 수 상한을 다 썼는데 아직 다음 쪽이 있음 — 일부만 받은 채 기간을 교체하지 않게(검토 F05)
raise ApiError(f"GS샵 {s.isoformat()}~{e.isoformat()} 조회가 {MAX_PAGES}쪽을 넘어 끝까지 받지 못했습니다 — "
"저장하지 않았습니다.")
ctx.progress.step(items=len(out))
s = e + timedelta(days=1)
return out
@@ -261,15 +267,19 @@ class GsshopAdapter(MarketplaceAdapter):
self.authenticate(ctx)
sup, _ = self._creds(ctx)
self._mode.pop(sup, None) # 입력값을 바꿨을 수 있으니 모드를 다시 찾는다
self._mode.pop(self._mode_key(ctx), None) # 입력값을 바꿨을 수 있으니 모드를 다시 찾는다
day = today_kst() - timedelta(days=1)
body = self._get(ctx, DAILY_SALES_PATH, {"stdDate": day.strftime("%Y%m%d"), "pageIdx": 1, "rowsPerPage": 10})
total = body.get("totalCount")
return (f"GS샵 연결 정상(매출 내역 조회 확인, 어제 매출 {total if total is not None else len(_rows(body))}건, "
f"토큰 {self._how_label(sup)}).")
f"토큰 {self._how_label(ctx)}).")
def _how_label(self, sup: str) -> str:
v, m = self._mode.get(sup, ("", ""))
@staticmethod
def _mode_key(ctx: AdapterContext) -> str:
return credential_fingerprint(ctx.credentials, ("vendor_code", "api_key"))
def _how_label(self, ctx: AdapterContext) -> str:
v, m = self._mode.get(self._mode_key(ctx), ("", ""))
return f"{MODE_LABEL.get(m, m)}, {KEY_LABEL.get(v, v)}"
# ── 원본 데이터 확인(설정 화면 "쇼핑몰 원본 데이터 확인") ─────────
@@ -264,6 +264,7 @@ class KakaoAdapter(MarketplaceAdapter):
"size": PAGE_SIZE}
out: list[dict[str, Any]] = []
token = ""
seen: set[str] = set()
for _ in range(MAX_PAGES):
body = self._get(ctx, PAID_PATH, {**params, **({"token": token} if token else {})})
rows = [r for r in body.get("contents") or [] if isinstance(r, dict)]
@@ -271,6 +272,11 @@ class KakaoAdapter(MarketplaceAdapter):
token = str(body.get("token") or "")
if not token or not rows:
break
if token in seen: # 커서 반복 — 끝까지 받았는지 알 수 없다(검토 F05)
raise ApiError(f"카카오 {d.isoformat()} 주문 목록의 다음 쪽 표시가 반복됩니다 — 저장하지 않았습니다.")
seen.add(token)
else: # 쪽 수 상한을 다 썼는데 아직 다음 쪽이 있음
raise ApiError(f"카카오 {d.isoformat()} 주문이 {MAX_PAGES}쪽을 넘어 끝까지 받지 못했습니다 — 저장하지 않았습니다.")
return out
def _detail(self, ctx: AdapterContext, row: dict[str, Any]) -> dict[str, Any]:
+11 -1
View File
@@ -28,6 +28,7 @@ from datetime import date, datetime, timedelta
from typing import Any, Iterable
from .base import (
credential_fingerprint,
AdapterContext,
AdapterError,
ApiError,
@@ -200,6 +201,9 @@ def group_orders(items: Iterable[dict[str, Any]], start: date, end: date) -> dic
return orders
# 토큰을 발급한 인증정보 — 이 값들이 바뀌면 저장된 토큰을 쓰지 않고 새로 받는다(credential_fingerprint)
TOKEN_KEYS = ("client_id", "client_secret", "account_id")
class NaverAdapter(MarketplaceAdapter):
code = "naver"
name = "네이버"
@@ -222,6 +226,8 @@ class NaverAdapter(MarketplaceAdapter):
help="솔루션(SELLER) 방식으로 발급한 경우에만 입력 — 내 스토어 전용 애플리케이션은 비워 둡니다"),
CredentialField("access_token", "Access Token", secret=True, required=False, internal=True),
CredentialField("access_token_expires_at", "Access Token 만료", required=False, internal=True),
# 토큰을 발급한 인증정보 지문(원문 아님) — 계정·키를 바꾸면 이전 토큰을 쓰지 않는다(2026-10-15 검토 F04)
CredentialField("access_token_for", "Access Token 발급 기준", required=False, internal=True),
]
# ── 인증 ──────────────────────────────────────────────
@@ -233,7 +239,8 @@ class NaverAdapter(MarketplaceAdapter):
exp = float(ctx.credentials.get("access_token_expires_at") or 0)
except ValueError:
exp = 0.0
if tok and exp - time.time() > TOKEN_MARGIN_SEC:
same_account = ctx.credentials.get("access_token_for") == credential_fingerprint(ctx.credentials, TOKEN_KEYS)
if tok and same_account and exp - time.time() > TOKEN_MARGIN_SEC:
return tok
return self._issue_token(ctx)
@@ -266,6 +273,7 @@ class NaverAdapter(MarketplaceAdapter):
expires_in = _won(body.get("expires_in")) or 3 * 3600
ctx.credentials.set("access_token", tok)
ctx.credentials.set("access_token_expires_at", str(int(time.time()) + expires_in))
ctx.credentials.set("access_token_for", credential_fingerprint(ctx.credentials, TOKEN_KEYS))
return tok
def authenticate(self, ctx: AdapterContext) -> None:
@@ -340,6 +348,8 @@ class NaverAdapter(MarketplaceAdapter):
out.extend(items)
if not items or not has_next(body, page, len(items)):
break
else: # 쪽 수 상한을 다 썼는데 아직 다음 쪽이 있음 — 일부만 받은 채 저장하지 않게(검토 F05)
raise ApiError(f"네이버 {d.isoformat()} 주문이 {MAX_PAGES}쪽을 넘어 끝까지 받지 못했습니다 — 저장하지 않았습니다.")
return out
def _items(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
+27 -1
View File
@@ -37,6 +37,7 @@ from datetime import date, datetime, timedelta, timezone
from typing import Any, Iterable
from .base import (
credential_fingerprint,
AdapterContext,
AdapterError,
ApiError,
@@ -245,6 +246,9 @@ def summary(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
return fields
# 토큰을 발급한 인증정보 — 이 값들이 바뀌면 저장된 토큰을 쓰지 않고 새로 받는다(credential_fingerprint)
TOKEN_KEYS = ("api_key", "api_secret")
class TossAdapter(MarketplaceAdapter):
code = "toss"
name = "토스쇼핑"
@@ -268,6 +272,8 @@ class TossAdapter(MarketplaceAdapter):
help="같은 화면의 Secret Key"),
CredentialField("access_token", "Access Token", secret=True, required=False, internal=True),
CredentialField("access_token_expires_at", "Access Token 만료", required=False, internal=True),
# 토큰을 발급한 인증정보 지문(원문 아님) — 계정·키를 바꾸면 이전 토큰을 쓰지 않는다(2026-10-15 검토 F04)
CredentialField("access_token_for", "Access Token 발급 기준", required=False, internal=True),
]
# ── 인증 ──────────────────────────────────────────────
@@ -279,7 +285,8 @@ class TossAdapter(MarketplaceAdapter):
exp = float(ctx.credentials.get("access_token_expires_at") or 0)
except ValueError:
exp = 0.0
if tok and exp - time.time() > TOKEN_MARGIN_SEC:
same_account = ctx.credentials.get("access_token_for") == credential_fingerprint(ctx.credentials, TOKEN_KEYS)
if tok and same_account and exp - time.time() > TOKEN_MARGIN_SEC:
return tok
return self._issue_token(ctx)
@@ -308,6 +315,7 @@ class TossAdapter(MarketplaceAdapter):
expires_in = _won(body.get("expires_in")) or 24 * 3600
ctx.credentials.set("access_token", tok)
ctx.credentials.set("access_token_expires_at", str(int(time.time()) + expires_in))
ctx.credentials.set("access_token_for", credential_fingerprint(ctx.credentials, TOKEN_KEYS))
return tok
def authenticate(self, ctx: AdapterContext) -> None:
@@ -383,6 +391,7 @@ class TossAdapter(MarketplaceAdapter):
params: dict[str, Any] = {"startDate": a.isoformat(), "endDate": b.isoformat(), "limit": PAGE_SIZE}
out: list[dict[str, Any]] = []
cursor = None
seen: set[str] = set()
for _ in range(MAX_PAGES):
body = self._get(ctx, ORDERS_PATH, {**params, **({"nextCursor": cursor} if cursor else {})})
rows = [r for r in body.get("results") or [] if isinstance(r, dict)]
@@ -390,6 +399,11 @@ class TossAdapter(MarketplaceAdapter):
cursor = body.get("nextCursor")
if not cursor or not rows:
break
if str(cursor) in seen: # 커서 반복 — 끝까지 받았는지 알 수 없다(검토 F05)
raise ApiError(f"토스 주문 {a.isoformat()}~{b.isoformat()} 다음 쪽 표시가 반복됩니다 — 저장하지 않았습니다.")
seen.add(str(cursor))
else:
raise ApiError(f"토스 주문 {a.isoformat()}~{b.isoformat()} 이 {MAX_PAGES}쪽을 넘어 끝까지 받지 못했습니다 — 저장하지 않았습니다.")
return out
def _settlement_items(self, ctx: AdapterContext, a: date, b: date) -> list[dict[str, Any]]:
@@ -398,6 +412,7 @@ class TossAdapter(MarketplaceAdapter):
"toDate": b.isoformat(), "size": SETTLEMENT_SIZE}
out: list[dict[str, Any]] = []
token = None
seen: set[str] = set()
for _ in range(MAX_PAGES):
body = self._get(ctx, SETTLEMENT_PATH, {**params, **({"nextToken": token} if token else {})})
rows = [r for r in body.get("items") or [] if isinstance(r, dict)]
@@ -405,12 +420,18 @@ class TossAdapter(MarketplaceAdapter):
token = body.get("nextToken")
if not token or not rows:
break
if str(token) in seen: # 커서 반복 — 끝까지 받았는지 알 수 없다(검토 F05)
raise ApiError(f"토스 정산 {a.isoformat()}~{b.isoformat()} 다음 쪽 표시가 반복됩니다 — 저장하지 않았습니다.")
seen.add(str(token))
else:
raise ApiError(f"토스 정산 {a.isoformat()}~{b.isoformat()} 이 {MAX_PAGES}쪽을 넘어 끝까지 받지 못했습니다 — 저장하지 않았습니다.")
return out
def _claims(self, ctx: AdapterContext) -> list[dict[str, Any]]:
"""클레임 목록 전체(유형·상태 조건 없음 = 전부 — 이 API 는 그 밖엔 날짜로 거를 수 없다), nextToken 으로 끝까지."""
out: list[dict[str, Any]] = []
token = None
seen: set[str] = set()
for _ in range(CLAIM_MAX_PAGES):
body = self._get(ctx, CLAIMS_PATH, {"size": CLAIM_PAGE_SIZE, **({"nextToken": token} if token else {})})
rows = [r for r in body.get("items") or [] if isinstance(r, dict)]
@@ -418,6 +439,11 @@ class TossAdapter(MarketplaceAdapter):
token = body.get("nextToken")
if not token or not rows or body.get("hasNext") is False:
break
if str(token) in seen: # 커서 반복 — 끝까지 받았는지 알 수 없다(검토 F05)
raise ApiError("토스 클레임 목록의 다음 쪽 표시가 반복됩니다 — 저장하지 않았습니다.")
seen.add(str(token))
else:
raise ApiError(f"토스 클레임 목록이 {CLAIM_MAX_PAGES}쪽을 넘어 끝까지 받지 못했습니다 — 저장하지 않았습니다.")
return out
@staticmethod
+22
View File
@@ -140,13 +140,17 @@ class CredentialService:
"""빈 칸 = 기존 값 유지. clear 에 든 항목은 삭제. 저장한 항목 키 목록 반환."""
allowed = {f.key for f in adapter.visible_fields()}
ring = self._ring_loader()
rows = self._store.credential_rows(adapter.code)
saved = []
changed = False # 화면 항목이 실제로 바뀌었나 — 바뀌었으면 그 인증정보로 받은 토큰 등 내부 값을 지운다(F04)
for key, raw in values.items():
if key not in allowed:
continue
v = (raw or "").strip()
if not v:
continue
if not changed and self._stored_value(adapter.code, key, rows) != v:
changed = True
self._store.upsert_credential(
adapter.code, key, encrypted_value=encrypt(v, aad=aad_for(adapter.code, key, self._ns), ring=ring),
key_version=ring.current_version, user=user,
@@ -154,9 +158,27 @@ class CredentialService:
saved.append(key)
for key in clear or []:
if key in allowed and key not in saved:
if key in rows:
changed = True
self._store.delete_credential(adapter.code, key)
if changed:
# 계정·키가 바뀌면 예전 계정으로 받은 토큰·만료 시각을 남기지 않는다. 같은 값을 다시 저장했으면 그대로 둔다
# (토큰을 불필요하게 다시 받지 않게). 어댑터도 토큰을 발급 인증정보 지문에 묶어 한 번 더 막는다.
for f in adapter.credential_fields():
if f.internal and f.key in rows:
self._store.delete_credential(adapter.code, f.key)
return saved
def _stored_value(self, code: str, key: str, rows: dict[str, Any]) -> str | None:
"""저장된 값 원문(서버 안에서만, 비교용) — 없거나 복호화할 수 없으면 None(= 바뀐 것으로 본다)."""
row = rows.get(key)
if not row:
return None
try:
return decrypt(row["encrypted_value"], aad=aad_for(code, key, self._ns), ring=self._ring_loader())
except Exception: # noqa: BLE001 — 키 교체·손상 등: 비교할 수 없으니 바뀐 것으로
return None
# ── 마스터 키 교체 후 재암호화 ─────────────────────────
def reencrypt_all(self) -> dict[str, int]:
"""예전 키 버전으로 된 암호문을 현재 키로 다시 암호화. (재암호화 수, 실패 수)."""
+11
View File
@@ -93,6 +93,17 @@ class ShopProgress(Progress):
with self._lock:
self.state = "saving"
def begin_saving(self) -> None:
"""수집이 끝나 저장으로 넘어간다 — 중지·취소 확인과 running → saving 전환을 **같은 잠금 안에서** 한다.
stop() 도 같은 잠금으로 state 를 보고 받아들이므로, [중지]가 이 전환보다 먼저면 여기서 Cancelled(저장 안 함),
나중이면 stop() 이 False(저장 중이라 중지 불가)를 돌려준다 — 둘 다 받아들여지는 틈이 없다(2026-10-15 검토 F06).
마지막 API 호출 중이나 collect() 정리 중에 받아들인 [중지]도 여기서 반영된다."""
with self._lock:
if self.cancel_requested:
raise Cancelled("사용자가 이 쇼핑몰 업데이트를 중지했습니다." if self.stopped_only else
"사용자가 업데이트를 취소했습니다.")
self.state = "saving"
def finish(self, *, upserted: int, message: str = "") -> None:
with self._lock:
self.state, self.upserted, self.message, self.status = "done", int(upserted), message, "ok"
+11 -4
View File
@@ -609,8 +609,7 @@ def api_ad_source_test(request: Request, code: str, payload: dict[str, Any] = Bo
src = _ad_source_or_404(code)
_, ad_sync = _ad_services(store)
values = {k: v for k, v in _clean_values(src, payload).items() if v.strip()}
allowed = {f.key for f in src.visible_fields()}
cleared = {str(k) for k in (payload.get("clear") or []) if str(k) in allowed and str(k) not in values}
cleared = _cleared_keys(src, payload, values)
return JSONResponse(ad_sync.test_connection(code, values=values or None, user=user["email"], cleared=cleared or None))
@@ -759,15 +758,23 @@ def api_save_credentials(request: Request, code: str, payload: dict[str, Any] =
@router.post("/api/marketplaces/{code}/test")
def api_test_connection(request: Request, code: str, payload: dict[str, Any] = Body(default={})) -> JSONResponse:
"""values 가 있으면 저장하지 않은 새 입력값으로 시험(빈 칸은 저장된 값 사용)."""
"""values 가 있으면 저장하지 않은 새 입력값으로 시험(빈 칸은 저장된 값 사용), clear = 화면에서 비운 항목은 빈 값으로.
광고 API 시험(/api/ad-sources/{code}/test)과 같은 요청·응답 계약 — 공통 설정 창이 둘 다 쓴다(검토 F09)."""
store, user = common.require_store(request, admin=True)
adapter = _code_or_404(store, code)
_, sync = common.services(request, store)
values = {k: v for k, v in _clean_values(adapter, payload).items() if v.strip()}
result = sync.test_connection(code, values=values or None, user=user["email"])
cleared = _cleared_keys(adapter, payload, values)
result = sync.test_connection(code, values=values or None, user=user["email"], cleared=cleared or None)
return JSONResponse(result)
def _cleared_keys(source: Any, payload: dict[str, Any], values: dict[str, str]) -> set[str]:
"""요청의 clear 중 이 연동의 화면 항목이면서 새 값이 없는 것 — 연결 시험에서 빈 값으로 본다."""
allowed = {f.key for f in source.visible_fields()}
return {str(k) for k in (payload.get("clear") or []) if str(k) in allowed and str(k) not in values}
@router.get("/api/marketplaces/{code}/reconcile")
def api_reconcile(request: Request, code: str, date_: str = Query(..., alias="date"), to: str | None = None) -> JSONResponse:
"""쇼핑몰 화면(예: 카페24 일별 매출내역)과 비교용 — 그날 원천 금액 항목별 합계. DB 는 바꾸지 않는다."""
+10 -7
View File
@@ -58,8 +58,8 @@ class SyncService:
self._app_state = app_state
def _ctx(self, adapter: MarketplaceAdapter, *, overrides: dict[str, str] | None = None,
persist: bool = True, user: str = "") -> AdapterContext:
acc = self._creds.accessor(adapter.code, overrides=overrides, persist=persist, user=user)
persist: bool = True, user: str = "", cleared: set[str] | None = None) -> AdapterContext:
acc = self._creds.accessor(adapter.code, overrides=overrides, persist=persist, user=user, cleared=cleared)
return AdapterContext(code=adapter.code, credentials=acc, app_state=self._app_state)
@staticmethod
@@ -72,15 +72,17 @@ class SyncService:
return "api_error", redact_text(f"예상하지 못한 오류: {type(exc).__name__}: {exc}", known)
# ── 연결 테스트 ─────────────────────────────────────────
def test_connection(self, code: str, *, values: dict[str, str] | None = None, user: str = "") -> dict[str, Any]:
"""values 를 주면 저장하지 않은 새 입력값으로 시험(저장된 상태는 바꾸지 않음)."""
def test_connection(self, code: str, *, values: dict[str, str] | None = None, user: str = "",
cleared: set[str] | None = None) -> dict[str, Any]:
"""values 를 주면 저장하지 않은 새 입력값으로, cleared = 화면에서 비운 항목은 저장값 대신 빈 값으로 시험한다.
둘 중 하나라도 있으면 저장하지 않은 시험이라 연결 상태·토큰을 저장하지 않는다(광고 API 시험과 같은 계약, 검토 F09)."""
adapter = get_adapter(code)
if adapter is None:
return {"ok": False, "status": "api_error", "message": "알 수 없는 쇼핑몰입니다."}
unsaved = bool(values)
unsaved = bool(values) or bool(cleared)
ctx = None
try:
ctx = self._ctx(adapter, overrides=values, persist=not unsaved, user=user)
ctx = self._ctx(adapter, overrides=values, persist=not unsaved, user=user, cleared=cleared)
message = adapter.test_connection(ctx)
status, ok = "ok", True
except Exception as exc: # noqa: BLE001 — 어떤 오류든 상태로 바꿔 화면에 보여 준다
@@ -119,7 +121,8 @@ class SyncService:
ctx.progress = progress
fetched, events = adapter.collect(ctx, start, end)
if progress is not None:
progress.saving()
# 중지 확인과 저장 시작을 한 잠금에서 — collect() 끝 무렵에 받아들인 [중지]면 여기서 Cancelled(저장 안 함)
progress.begin_saving()
known = ctx.credentials.known_secrets()
rows = [event_row(ev, known) for ev in events]
# 다른 쇼핑몰 열로 보낸 사건 — 등록된 쇼핑몰이 아니면 이 쇼핑몰 열에 둔다(합계가 빠지지 않게).
@@ -596,6 +596,8 @@ def test_toss_reconcile_hides_personal():
ctx = AdapterContext(code="toss", credentials=_TossCreds(api_key="a", api_secret="b", access_token="T",
access_token_expires_at=str(int(_t.time()) + 99999)))
from app.modules.performance.adapters import toss as _toss # 지금 인증정보로 받은 토큰(검토 F04 — 지문이 같아야 재사용)
ctx.credentials.set("access_token_for", _toss.credential_fingerprint(ctx.credentials, _toss.TOKEN_KEYS))
rows = [_toss_item(1, 11, "2026-09-09T10:00:00", 20000, ship=3000, group=1),
_toss_item(2, 21, "2026-09-09T11:00:00", 9900, status="CANCELED_PAYMENT", ship=3000, group=2)]
steps = [_toss_step("REFUND", 2, 21, "2026-09-10T11:00:00", -9900), _toss_step("REFUND", 2, None, "2026-09-10T11:00:00", -3000)]
@@ -1558,6 +1560,8 @@ def test_naver_reconcile_hides_personal():
import time as _t
ctx = AdapterContext(code="naver", credentials=Creds(client_id="x", client_secret="y", access_token="T",
access_token_expires_at=str(int(_t.time()) + 9999)))
# 저장된 토큰은 발급한 인증정보 지문과 같을 때만 다시 쓴다(검토 F04) — 지금 인증정보로 받은 토큰으로
ctx.credentials.set("access_token_for", nv.credential_fingerprint(ctx.credentials, nv.TOKEN_KEYS))
rows = [_naver_item("A", "A1", "2026-09-09", 20000, ship=3000), _naver_item("B", "B1", "2026-09-09", 9900, status="CANCELED")]
orig = (httpx.get, nv.CALL_INTERVAL_SEC)
httpx.get = lambda url, params=None, headers=None, timeout=None: httpx.Response(
@@ -0,0 +1,310 @@
"""2026-10-15 코드 검토(docs/CODE_REVIEW_2026-10-15.md) 실적 항목 회귀 테스트 — DB·네트워크 없이(가짜 저장소·가짜 HTTP).
F01 쿠팡 잘못된 응답(HTTP 200 + JSON 아님·data 없음)은 수집 실패 — 기존 매출 유지(replace_events 안 부름)
F04 인증정보가 바뀌면 이전 계정 토큰을 쓰지 않음(저장 때 내부 토큰 삭제 + 토큰-인증정보 지문), 같은 값 재저장은 유지
F05 쪽 수 상한·커서 반복이면 부분 수집을 성공으로 내지 않음(쿠팡은 기간을 나눠 다시), 다른 어댑터도 실패로
F06 collect() 끝 무렵 받아들인 [중지]는 저장 전에 반영, 저장을 시작했으면 [중지] 불가
F09 쇼핑몰 연결 테스트도 clear(비운 칸)를 빈 값으로 시험하고, 저장하지 않은 시험은 연결 상태를 바꾸지 않음
"""
from __future__ import annotations
import time
from datetime import date
import httpx
import pytest
from app.modules.performance.adapters import coupang as cp
from app.modules.performance.adapters import gsshop as gs
from app.modules.performance.adapters import kakao as kk
from app.modules.performance.adapters import naver as nv
from app.modules.performance.adapters import toss as ts
from app.modules.performance.adapters.base import AdapterContext, ApiError
from app.modules.performance.adapters.registry import get_adapter
from app.modules.performance.credentials import CredentialService
from app.modules.performance.sync import SyncService
from app.modules.performance.tests.test_performance import FakeStore, _naver_item, ring
class Creds(dict):
def get(self, k, default=""):
return dict.get(self, k, default)
def has(self, k):
return bool(dict.get(self, k))
def set(self, k, v):
self[k] = v
def known_secrets(self):
return []
def _cp_ctx():
return AdapterContext(code="coupang", credentials=Creds(vendor_id="A00012345", access_key="AK", secret_key="SK"))
@pytest.fixture
def no_wait(monkeypatch):
monkeypatch.setattr(cp, "CALL_INTERVAL_SEC", 0)
monkeypatch.setattr(cp, "RG_CALL_INTERVAL_SEC", 0)
monkeypatch.setattr(cp.time, "sleep", lambda *_a, **_k: None)
def _coupang_store_with_sales():
"""기존 쿠팡 매출 한 줄(10/12)이 있는 가짜 저장소 + 쿠팡 인증정보. replace_events 호출을 기록한다."""
st = FakeStore()
st.events[("coupang", "SALE", "coupang:9")] = {"sales_date": date(2026, 10, 12), "amount": 15000,
"event_type": "SALE", "is_sample": False}
st.replaced = []
orig = st.replace_events
def replace(code, start, end, events, *, id_prefix=""):
st.replaced.append((code, start, end, list(events)))
return orig(code, start, end, events, id_prefix=id_prefix)
st.replace_events = replace
creds = CredentialService(st, lambda: ring())
creds.save(get_adapter("coupang"), {"vendor_id": "A00012345", "access_key": "AK-1", "secret_key": "SK-1"})
return st, creds
# ── F01 ─────────────────────────────────────────────────────
@pytest.mark.parametrize("response", [
httpx.Response(200, text="<html>maintenance</html>"), # JSON 아님
httpx.Response(200, json={"message": "점검 중입니다"}), # 주문 목록(data) 없음
httpx.Response(200, json={"code": 200, "data": {"unexpected": True}}), # data 가 목록 아님
])
def test_f01_bad_200_response_fails_and_keeps_existing_sales(monkeypatch, no_wait, response):
st, creds = _coupang_store_with_sales()
monkeypatch.setattr(httpx, "get", lambda *a, **k: response)
r = SyncService(st, creds).sync_marketplace("coupang", date(2026, 10, 12), date(2026, 10, 12))
assert not r["ok"] and r["status"] == "api_error", r
assert st.replaced == [] # 기간 교체(삭제)를 아예 하지 않음
assert ("coupang", "SALE", "coupang:9") in st.events # 기존 매출 그대로
assert st.status["coupang"]["ok"] is False and "저장하지 않았습니다" in r["message"]
def test_f01_empty_list_is_still_a_normal_empty_period(monkeypatch, no_wait):
"""정상 빈 목록(data: [])은 주문 0건 — 기간 교체가 정상적으로 일어난다(실패와 구분)."""
st, creds = _coupang_store_with_sales()
monkeypatch.setattr(httpx, "get", lambda *a, **k: httpx.Response(200, json={"code": 200, "data": [], "nextToken": ""}))
r = SyncService(st, creds).sync_marketplace("coupang", date(2026, 10, 12), date(2026, 10, 12))
assert r["ok"], r
assert len(st.replaced) == 1 and st.replaced[0][3] == []
def test_f01_page_rows_contract():
assert cp.CoupangAdapter._page_rows({"code": 200, "data": []}, "발주서") == []
assert cp.CoupangAdapter._page_rows({"code": 200, "message": "OK", "data": None}, "발주서") == [] # 성공 표시 + null
assert cp.CoupangAdapter._page_rows({"data": [{"a": 1}, "x"]}, "발주서") == [{"a": 1}]
for body in ({}, {"data": None}, {"message": "maintenance"}, {"data": "x"}):
with pytest.raises(ApiError):
cp.CoupangAdapter._page_rows(body, "발주서")
# ── F05 ─────────────────────────────────────────────────────
def test_f05_coupang_page_limit_and_repeated_cursor_raise(monkeypatch, no_wait):
ad = cp.CoupangAdapter()
monkeypatch.setattr(cp, "MAX_PAGES", 2)
n = {"i": 0}
def endless(*a, **k):
n["i"] += 1
return httpx.Response(200, json={"code": 200, "data": [{"orderId": n["i"]}], "nextToken": f"t{n['i']}"})
monkeypatch.setattr(httpx, "get", endless)
with pytest.raises(cp.TooManyPages):
ad._pages(_cp_ctx(), "/x", {})
monkeypatch.setattr(httpx, "get", lambda *a, **k: httpx.Response(200, json={"code": 200, "data": [{"a": 1}], "nextToken": "same"}))
with pytest.raises(cp.TooManyPages, match="반복"):
ad._pages(_cp_ctx(), "/x", {})
def test_f05_coupang_splits_period_until_complete_or_fails(monkeypatch, no_wait):
"""2일 조회가 쪽 수 상한을 넘으면 하루씩 나눠 끝까지 받는다. 하루도 넘치면 명확한 실패."""
ad = cp.CoupangAdapter()
monkeypatch.setattr(cp, "MAX_PAGES", 3)
calls = []
def get(url, headers=None, timeout=None):
q = dict(p.split("=", 1) for p in url.split("?", 1)[1].split("&"))
calls.append((q["paidDateFrom"], q["paidDateTo"]))
if q["paidDateFrom"] != q["paidDateTo"]: # 여러 날 — 끝이 안 보임
i = int(q.get("nextToken", "0")) + 1
return httpx.Response(200, json={"data": [{"orderId": i}], "nextToken": str(i)})
return httpx.Response(200, json={"data": [{"orderId": q["paidDateFrom"]}], "nextToken": ""})
monkeypatch.setattr(httpx, "get", get)
rows = ad._rg_orders(_cp_ctx(), date(2026, 10, 11), date(2026, 10, 12))
assert sorted(r["orderId"] for r in rows) == ["20261011", "20261012"] # 부분 목록이 아니라 하루씩 전부
assert ("20261011", "20261011") in calls and ("20261012", "20261012") in calls
monkeypatch.setattr(httpx, "get", lambda url, headers=None, timeout=None: httpx.Response(
200, json={"data": [{"orderId": 1}], "nextToken": str(time.perf_counter_ns())}))
with pytest.raises(ApiError, match="하루"):
ad._rg_orders(_cp_ctx(), date(2026, 10, 12), date(2026, 10, 12))
def test_f05_other_adapters_fail_instead_of_partial(monkeypatch):
"""네이버·카카오·토스·GS샵 — 상한 소진·커서 반복은 실패(일부만 받은 목록을 돌려주지 않음)."""
ctx = AdapterContext(code="x", credentials=Creds())
d = date(2026, 10, 12)
monkeypatch.setattr(nv, "MAX_PAGES", 2)
a = nv.NaverAdapter()
a._get = lambda ctx, path, params: {"data": {"contents": [_naver_item(f"O{params['page']}", f"P{params['page']}",
"2026-10-12", 1000)],
"pagination": {"page": params["page"], "hasNext": True}}}
with pytest.raises(ApiError, match="끝까지"):
a._day_items(ctx, d)
k = kk.KakaoAdapter()
k._get = lambda ctx, path, params: {"contents": [{"orderId": "1"}], "token": "same"}
with pytest.raises(ApiError, match="반복"):
k._day_rows(ctx, d)
t = ts.TossAdapter()
t._get = lambda ctx, path, params: {"results": [{"id": 1}], "nextCursor": "c"}
with pytest.raises(ApiError, match="반복"):
t._window_items(ctx, d, d)
t._get = lambda ctx, path, params: {"items": [{"id": 1}], "nextToken": "n"}
with pytest.raises(ApiError, match="반복"):
t._settlement_items(ctx, d, d)
with pytest.raises(ApiError, match="반복"):
t._claims(ctx)
monkeypatch.setattr(gs, "MAX_PAGES", 2)
g = gs.GsshopAdapter()
g._get = lambda ctx, path, params: {"data": [{"ordNo": params["pageIdx"]}], "hasMorePage": True}
with pytest.raises(ApiError, match="끝까지"):
g._pages(ctx, gs.SALES_PATH, d, d)
# ── F06 ─────────────────────────────────────────────────────
def test_f06_stop_accepted_at_end_of_collect_is_not_saved(monkeypatch, no_wait):
from app.modules.performance import jobs
st, creds = _coupang_store_with_sales()
job = jobs.SyncJob(user="t", start=None, end=None)
shop = job.set_targets([("coupang", "쿠팡", True)], date(2026, 10, 12), date(2026, 10, 12))["coupang"]
ad = get_adapter("coupang")
def collect(ctx, start, end): # 마지막 API 호출·정리 중에 [중지]가 들어온 상황
assert job.stop_shop("coupang") is True
return 1, []
monkeypatch.setattr(ad, "collect", collect)
r = SyncService(st, creds).sync_marketplace("coupang", date(2026, 10, 12), date(2026, 10, 12), progress=shop)
assert r.get("cancelled") and r["status"] == "cancelled", r
assert st.replaced == [] and ("coupang", "SALE", "coupang:9") in st.events # 저장 안 함
assert shop.state == "cancelled" and shop.message == "중지됨"
def test_f06_stop_after_saving_started_is_refused():
from app.modules.performance import jobs
job = jobs.SyncJob(user="t", start=None, end=None)
shop = job.set_targets([("coupang", "쿠팡", True)], date(2026, 10, 12), date(2026, 10, 12))["coupang"]
shop.start()
shop.begin_saving()
assert shop.state == "saving"
assert job.stop_shop("coupang") is False and shop.stop_requested is False # 저장 중이면 중지 불가를 알림
# ── F04 ─────────────────────────────────────────────────────
def _toss_svc():
st = FakeStore()
svc = CredentialService(st, lambda: ring())
ad = get_adapter("toss")
svc.save(ad, {"api_key": "k1", "api_secret": "s1"})
acc = svc.accessor("toss")
acc.set("access_token", "OLD_ACCOUNT_TOKEN")
acc.set("access_token_expires_at", str(int(time.time()) + 86400))
acc.set("access_token_for", ts.credential_fingerprint(acc, ts.TOKEN_KEYS))
return st, svc, ad
def test_f04_same_values_keep_token_changed_values_drop_it(monkeypatch):
st, svc, ad = _toss_svc()
issued = []
monkeypatch.setattr(httpx, "post", lambda *a, **k: issued.append(1) or httpx.Response(
200, json={"access_token": "NEW_ACCOUNT_TOKEN", "expires_in": 3600}))
svc.save(ad, {"api_key": "k1", "api_secret": "s1"}) # 같은 값 다시 저장
assert ("toss", "access_token") in st.creds
ctx = AdapterContext(code="toss", credentials=svc.accessor("toss"))
assert ad._token(ctx) == "OLD_ACCOUNT_TOKEN" and issued == [] # 불필요한 재발급 없음
svc.save(ad, {"api_key": "k2"}) # 계정(키) 변경
assert ("toss", "access_token") not in st.creds and ("toss", "access_token_expires_at") not in st.creds
ctx = AdapterContext(code="toss", credentials=svc.accessor("toss"))
assert ad._token(ctx) == "NEW_ACCOUNT_TOKEN" and issued == [1]
def test_f04_token_bound_to_credentials_even_without_save(monkeypatch):
"""연결 테스트(저장 안 한 새 입력값)·예전 토큰(지문 없음)도 이전 계정 토큰을 쓰지 않는다 — 실제 수집과 같은 기준."""
st, svc, ad = _toss_svc()
monkeypatch.setattr(httpx, "post", lambda *a, **k: httpx.Response(200, json={"access_token": "NEW", "expires_in": 3600}))
trial = AdapterContext(code="toss", credentials=svc.accessor("toss", overrides={"api_key": "k2"}, persist=False))
assert ad._token(trial) == "NEW"
assert svc.accessor("toss").get("access_token") == "OLD_ACCOUNT_TOKEN" # 시험은 저장된 토큰을 건드리지 않음
# 지문이 없는 예전 토큰(배포 전에 저장된 것)은 한 번 새로 받는다
svc.accessor("toss").set("access_token_for", "")
real = AdapterContext(code="toss", credentials=svc.accessor("toss"))
assert ad._token(real) == "NEW" and svc.accessor("toss").get("access_token") == "NEW"
def test_f04_fingerprint_hides_values_and_gs_mode_cache_follows_key():
fp = ts.credential_fingerprint(Creds(api_key="secret-key-1", api_secret="s"), ts.TOKEN_KEYS)
assert len(fp) == 64 and "secret" not in fp
a = AdapterContext(code="gsshop", credentials=Creds(vendor_code="1036018", api_key="K1" * 16))
b = AdapterContext(code="gsshop", credentials=Creds(vendor_code="1036018", api_key="K2" * 16))
assert gs.GsshopAdapter._mode_key(a) != gs.GsshopAdapter._mode_key(b)
# ── F09 ─────────────────────────────────────────────────────
def test_f09_shop_test_uses_empty_value_for_cleared_and_keeps_status(monkeypatch):
st = FakeStore()
svc = CredentialService(st, lambda: ring())
ad = get_adapter("naver")
svc.save(ad, {"client_id": "cid", "client_secret": "$2a$04$abcdefghijklmnopqrstuu", "account_id": "OLD-SELLER"})
st.status["naver"] = {"status": "ok", "ok": True, "error": ""}
seen = []
monkeypatch.setattr(ad, "test_connection", lambda ctx: seen.append(ctx.credentials.get("account_id")) or "연결됨")
r = SyncService(st, svc).test_connection("naver", cleared={"account_id"})
assert seen == [""] and r["ok"] and r["unsaved"] is True # 비운 칸은 빈 값, 저장 안 한 시험
assert st.status["naver"] == {"status": "ok", "ok": True, "error": ""} # 연결 상태 그대로
assert svc.accessor("naver").get("account_id") == "OLD-SELLER" # 저장값도 그대로
r = SyncService(st, svc).test_connection("naver") # 저장값 그대로 시험은 상태 기록
assert seen[-1] == "OLD-SELLER" and r["unsaved"] is False and st.status["naver"].get("test")
def test_f09_router_passes_clear_like_ad_test(monkeypatch):
import importlib
from fastapi import FastAPI
from fastapi.testclient import TestClient
from app.modules.performance import common
perf_router = importlib.import_module("app.modules.performance.router")
calls = []
class Sync:
def test_connection(self, code, *, values=None, user="", cleared=None):
calls.append((code, values, cleared))
return {"ok": True, "status": "ok", "label": "정상 연결", "message": "연결됨", "unsaved": bool(values or cleared)}
st = FakeStore()
st.list_marketplaces = lambda: [{"code": "naver", "name": "네이버"}]
monkeypatch.setattr(common, "require_store", lambda request, admin=False: (st, {"email": "king@x"}))
monkeypatch.setattr(common, "services", lambda request, store: (None, Sync()))
app = FastAPI()
app.include_router(perf_router.router)
c = TestClient(app)
r = c.post("/performance/api/marketplaces/naver/test",
json={"values": {"client_id": "new"}, "clear": ["account_id", "client_id", "nope"]})
assert r.status_code == 200 and r.json()["unsaved"] is True
assert calls[-1] == ("naver", {"client_id": "new"}, {"account_id"}) # 새 값이 있는 칸·모르는 칸은 빼고