Files
dbx-main/app/modules/performance/tests/test_performance.py
T
king da63b93302 feat(performance): 매출 업데이트 취소 버튼
- 진행 창 [업데이트 취소](시작한 사람·관리자) → POST /api/sync/jobs/{id}/cancel
- 어댑터가 API 호출 직전마다 ctx.progress.check() — 취소면 Cancelled 로 멈추고 저장하지 않음(기존 매출 그대로),
  차례가 안 온 쇼핑몰은 취소됨으로 건너뜀, 이미 끝난 쇼핑몰 결과는 유지
- 취소 실행은 perf_sync_runs failed + 업데이트 취소, 연결 상태는 바꾸지 않음
- 테스트 1개 추가(30개 통과), performance.js/css 캐시 버전, 문서 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 15:06:25 +09:00

1397 lines
79 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""실적 모듈 테스트 — 암호화·가리기·계산·인증정보·동기화. DB/네트워크 없이 가짜 저장소로.
python -m app.modules.performance.tests.test_performance
또는 pytest 로 실행 가능.
"""
from __future__ import annotations
import os
from datetime import date, timedelta
from decimal import Decimal
from app.modules.performance import calc
from app.modules.performance.adapters import mock
from app.modules.performance.adapters.base import (
ApiError,
AuthFailed,
CredentialField,
MarketplaceAdapter,
SaleEvent,
)
from app.modules.performance.adapters.registry import all_adapters
from app.modules.performance.credentials import CredentialService, aad_for
from app.modules.performance.security import crypto
from app.modules.performance.security.redact import MASK, mask, redact_mapping, redact_text
from app.modules.performance.sync import SyncService, event_row, sales_date_for
KEY1 = "11" * 32
KEY2 = "22" * 32
def ring(version: int = 1, **old: str) -> crypto.KeyRing:
env = {"APP_ENCRYPTION_KEY": KEY1 if version == 1 else KEY2, "APP_ENCRYPTION_KEY_VERSION": str(version)}
env.update(old)
return crypto.KeyRing.from_env(env)
# ════════════════════════════════════════════════════════════
# 암호화
# ════════════════════════════════════════════════════════════
def test_crypto_roundtrip_and_format():
r = ring()
token = crypto.encrypt("my-secret-value", aad="perf:coupang:secret_key", ring=r)
assert token.startswith("v1:")
assert "my-secret-value" not in token
assert crypto.decrypt(token, aad="perf:coupang:secret_key", ring=r) == "my-secret-value"
# 같은 평문도 매번 다른 암호문(nonce)
assert token != crypto.encrypt("my-secret-value", aad="perf:coupang:secret_key", ring=r)
def test_crypto_rejects_wrong_aad_tamper_and_key():
r = ring()
token = crypto.encrypt("abc", aad="perf:coupang:secret_key", ring=r)
for bad in (lambda: crypto.decrypt(token, aad="perf:naver:client_secret", ring=r),
lambda: crypto.decrypt(token[:-2] + ("A" if token[-2] != "A" else "B") + token[-1], aad="perf:coupang:secret_key", ring=r),
lambda: crypto.decrypt(token, aad="perf:coupang:secret_key",
ring=crypto.KeyRing.from_env({"APP_ENCRYPTION_KEY": KEY2}))):
try:
bad()
except crypto.DecryptError as exc:
assert "abc" not in str(exc)
else:
raise AssertionError("복호화가 실패해야 합니다")
def test_crypto_missing_or_bad_key():
for env in ({}, {"APP_ENCRYPTION_KEY": "short"}, {"APP_ENCRYPTION_KEY": KEY1, "APP_ENCRYPTION_KEY_VERSION": "0"}):
try:
crypto.KeyRing.from_env(env)
except crypto.CryptoConfigError:
pass
else:
raise AssertionError(f"설정 오류여야 합니다: {list(env)}")
# base64 32바이트 키도 받는다
import base64
b64 = base64.urlsafe_b64encode(bytes(range(32))).decode()
assert crypto.KeyRing.from_env({"APP_ENCRYPTION_KEY": b64}).current_version == 1
assert "11" * 4 not in repr(ring()) # 키 값이 repr 에 나오지 않음
def test_crypto_rotation():
old = ring(1)
token = crypto.encrypt("rotate-me", aad="a", ring=old)
new = ring(2, APP_ENCRYPTION_KEY_V1=KEY1)
assert new.versions == [1, 2]
assert crypto.needs_reencrypt(token, new)
assert crypto.decrypt(token, aad="a", ring=new) == "rotate-me"
token2 = crypto.encrypt("rotate-me", aad="a", ring=new)
assert token2.startswith("v2:") and not crypto.needs_reencrypt(token2, new)
try:
crypto.decrypt(token, aad="a", ring=ring(2)) # 예전 키를 안 남기면 실패
except crypto.DecryptError as exc:
assert "v1" in str(exc)
else:
raise AssertionError("예전 키 없이는 복호화 실패해야 합니다")
# ════════════════════════════════════════════════════════════
# 가리기
# ════════════════════════════════════════════════════════════
def test_redact():
secret = "SK-live-9f8e7d6c5b4a"
msg = f"401 Unauthorized secret={secret} Authorization: Bearer abcdef123456 token=zzz999 other=ok"
out = redact_text(msg, [secret])
assert secret not in out and "abcdef123456" not in out and "zzz999" not in out
assert "other=ok" in out and MASK in out
assert "Cookie" not in redact_text("Cookie: sid=abc; x=1").replace(f"Cookie: {MASK}", "")
j = redact_text('{"access_token": "tok-123456", "vendor": "A001"}')
assert "tok-123456" not in j and "A001" in j
data = redact_mapping({"order": "1", "headers": {"Authorization": "x", "X-Api-Key": "y"}, "items": [{"password": "p"}]})
assert data["order"] == "1" and data["headers"]["Authorization"] == MASK
assert data["headers"]["X-Api-Key"] == MASK and data["items"][0]["password"] == MASK
assert mask("ABCDEFGHIJKL1234") == "ABCD****1234" and mask("short") == MASK
assert len(redact_text("x" * 1000)) <= 301
# ════════════════════════════════════════════════════════════
# 계산
# ════════════════════════════════════════════════════════════
def test_commission_rounding():
assert calc.commission(1_000_000, Decimal("10")) == 100_000
assert calc.commission(12_345, Decimal("10.8")) == 1_333 # 1333.26 → 1333
assert calc.commission(15, Decimal("10")) == 2 # 1.5 → 2 (half up)
assert calc.commission(-15, Decimal("10")) == -2 # 취소도 같은 규칙
assert calc.commission(100_000, Decimal("15.35")) == 15_350
assert calc.commission(0, Decimal("10")) == 0 and calc.commission(1000, Decimal("0")) == 0
m = calc.Money(gross=1_000_000, commission=100_000)
assert m.net == 900_000
def test_rate_history():
rates = {"coupang": [(date(2026, 1, 1), Decimal("8")), (date(2026, 7, 1), Decimal("10"))]}
assert calc.rate_on(rates, "coupang", date(2025, 12, 31)) == 0
assert calc.rate_on(rates, "coupang", date(2026, 6, 30)) == 8
assert calc.rate_on(rates, "coupang", date(2026, 7, 1)) == 10
assert calc.rate_on(rates, "naver", date(2026, 7, 1)) == 0
cells = calc.build_cells({(date(2026, 6, 30), "coupang"): 100_000, (date(2026, 7, 1), "coupang"): 100_000}, rates)
assert cells[(date(2026, 6, 30), "coupang")].commission == 8_000
assert cells[(date(2026, 7, 1), "coupang")].commission == 10_000
def test_periods():
wed = date(2026, 9, 30)
p = calc.resolve_period("week", wed)
assert (p.start, p.end) == (date(2026, 9, 28), date(2026, 10, 4)) # 월~일
assert p.start.weekday() == 0 and p.end.weekday() == 6 and p.days == 7
assert p.prev_anchor == date(2026, 9, 21)
m = calc.resolve_period("month", date(2026, 2, 15))
assert (m.start, m.end) == (date(2026, 2, 1), date(2026, 2, 28))
y = calc.resolve_period("year", wed)
assert (y.start, y.end) == (date(2026, 1, 1), date(2026, 12, 31))
c = calc.resolve_period("custom", wed, custom_from=date(2026, 9, 29), custom_to=date(2026, 9, 1))
assert (c.start, c.end) == (date(2026, 9, 1), date(2026, 9, 29))
# 진행 중인 주 — 전주 같은 요일까지만 비교
s, e, label = p.compare_range(today=wed)
assert (s, e) == (date(2026, 9, 21), date(2026, 9, 23)) and label.startswith("전주")
# 지난 주 — 전주 전체
s, e, _ = calc.resolve_period("week", date(2026, 9, 20)).compare_range(today=wed)
assert (s, e) == (date(2026, 9, 7), date(2026, 9, 13))
# 진행 중인 달 — 전월 같은 날까지(말일 넘지 않게)
s, e, _ = calc.resolve_period("month", date(2026, 3, 31)).compare_range(today=date(2026, 3, 31))
assert (s, e) == (date(2026, 2, 1), date(2026, 2, 28))
assert calc.pct_change(110, 100) == 10.0 and calc.pct_change(5, 0) is None and calc.pct_change(0, 0) is None
def _cells_for(days, codes, amount=10_000):
return calc.build_cells({(d, c): amount for d in days for c in codes}, {"a": [(date(2000, 1, 1), Decimal("10"))]})
def test_main_table_week():
p = calc.resolve_period("week", date(2026, 9, 30))
days = list(calc.daterange(p.start, p.end))
cells = _cells_for(days, ["a", "b"])
rows = calc.main_table(p, ["a", "b"], cells, today=date(2026, 9, 30), holidays={"2026-10-03": "개천절"})
assert [r["kind"] for r in rows] == ["day"] * 7 + ["week"]
assert rows[0]["label"] == "09/28(월)" and rows[6]["label"] == "10/04(일)"
assert rows[5]["holiday"] == "개천절" and rows[2]["today"] and rows[3]["future"]
week = rows[-1]
assert week["cells"]["a"] == {"gross": 70_000, "commission": 7_000, "net": 63_000}
assert week["cells"]["b"]["commission"] == 0 # 요율 없는 쇼핑몰 = 0%
assert week["total"]["gross"] == 140_000
assert rows[0]["total"]["gross"] == 20_000
def test_main_table_month_and_year():
p = calc.resolve_period("month", date(2026, 9, 10))
cells = _cells_for(list(calc.daterange(p.start, p.end)), ["a"])
rows = calc.main_table(p, ["a"], cells, today=date(2026, 9, 30))
weeks = [r for r in rows if r["kind"] == "week"]
assert rows[-1]["kind"] == "total" and rows[-1]["total"]["gross"] == 300_000
assert sum(w["total"]["gross"] for w in weeks) == 300_000
assert weeks[0]["from"] == "2026-09-01" and weeks[0]["to"] == "2026-09-06" # 첫 주는 월 시작부터
y = calc.resolve_period("year", date(2026, 9, 10))
yrows = calc.main_table(y, ["a"], cells, today=date(2026, 9, 30))
assert len(yrows) == 13 and yrows[8]["total"]["gross"] == 300_000 and yrows[9]["future"]
ym = calc.year_months(2026, ["a"], cells, today=date(2026, 9, 30))
assert ym["rows"][9]["gross"] is None and ym["rows"][8]["gross"] == 300_000 and ym["total"]["gross"] == 300_000
ms = calc.month_summary(2026, 9, ["a"], cells)
assert ms["rows"][0]["share"] == 100.0 and ms["total"]["net"] == 270_000
# ════════════════════════════════════════════════════════════
# 가짜 저장소 + 인증정보
# ════════════════════════════════════════════════════════════
class FakeStore:
def __init__(self):
self.creds: dict[tuple[str, str], dict] = {}
self.events: dict[tuple[str, str, str], dict] = {}
self.status: dict[str, dict] = {}
self.running: set[str] = set()
self.markets = [{"code": a.code, "name": a.name, "enabled": True, "include_in_sales": True} for a in all_adapters()]
def credential_rows(self, code):
return {k: {**v, "updated_at": None} for (c, k), v in self.creds.items() if c == code}
def credential_keys_by_code(self):
out = {}
for c, k in self.creds:
out.setdefault(c, set()).add(k)
return out
def upsert_credential(self, code, key, *, encrypted_value, key_version, user=""):
self.creds[(code, key)] = {"encrypted_value": encrypted_value, "key_version": key_version}
def delete_credential(self, code, key):
self.creds.pop((code, key), None)
def all_credential_rows(self):
return [{"marketplace_code": c, "credential_key": k, **v} for (c, k), v in self.creds.items()]
def list_marketplaces(self):
return self.markets
def start_run(self, code, **_):
if code in self.running:
return None
self.running.add(code)
return len(self.running)
def finish_run(self, run_id, **_):
self.running.clear()
def record_sync(self, code, *, status, ok, error=""):
self.status[code] = {"status": status, "ok": ok, "error": error}
def record_test(self, code, *, status, ok, error=""):
self.status[code] = {"status": status, "ok": ok, "error": error, "test": True}
def replace_events(self, code, start, end, events, *, id_prefix=""):
def mine(k, v):
return k[0] == code or (id_prefix and k[2].startswith(id_prefix))
self.events = {k: v for k, v in self.events.items()
if not (mine(k, v) and not v["is_sample"] and start <= v["sales_date"] <= end)}
return self.upsert_events(code, events)
def daily_breakdown(self, code, start, end, *, id_prefix=""):
days = {}
for (c, _, eid), v in self.events.items():
if v["is_sample"] or not (start <= v["sales_date"] <= end):
continue
if not (c == code or (id_prefix and eid.startswith(id_prefix))):
continue
r = days.setdefault(v["sales_date"].isoformat(), {"date": v["sales_date"].isoformat(), "paid": 0,
"orders": 0, "refund": 0, "synced_at": None})
if v["event_type"] == "SALE":
r["paid"] += v["amount"]
r["orders"] += 1
else:
r["refund"] -= v["amount"]
return sorted(days.values(), key=lambda r: r["date"])
def upsert_events(self, code, events, *, is_sample=False):
n = 0
for e in events:
target = e.get("marketplace_code") or code
self.events[(target, e["event_type"], e["external_event_id"])] = {**e, "is_sample": is_sample}
n += 1
return n
def _coupang():
return next(a for a in all_adapters() if a.code == "coupang")
def test_credentials_encrypted_and_never_returned():
st = FakeStore()
svc = CredentialService(st, lambda: ring())
ad = _coupang()
saved = svc.save(ad, {"vendor_id": "A00012345", "access_key": "AK-plain-111", "secret_key": "SK-plain-222",
"unknown": "x"}, user="t@x")
assert sorted(saved) == ["access_key", "secret_key", "vendor_id"]
for (code, key), row in st.creds.items():
assert "plain" not in row["encrypted_value"] and "A00012345" not in row["encrypted_value"]
assert row["encrypted_value"].startswith("v1:") and row["key_version"] == 1
info = svc.describe(ad)
as_text = repr(info)
assert "AK-plain-111" not in as_text and "SK-plain-222" not in as_text
by_key = {f["key"]: f for f in info["fields"]}
assert by_key["secret_key"]["has_value"] and "value" not in by_key["secret_key"]
assert by_key["vendor_id"]["value"] == "A00012345" and info["configured"]
# 빈 칸 = 유지, 다른 쇼핑몰 칸으로 옮긴 암호문은 풀리지 않음(AAD)
svc.save(ad, {"secret_key": "", "access_key": "AK-new"})
acc = svc.accessor("coupang")
assert acc.get("secret_key") == "SK-plain-222" and acc.get("access_key") == "AK-new"
moved = st.creds[("coupang", "secret_key")]["encrypted_value"]
try:
crypto.decrypt(moved, aad=aad_for("naver", "client_secret"), ring=ring())
except crypto.DecryptError:
pass
else:
raise AssertionError("다른 칸의 암호문은 복호화되면 안 됩니다")
# 재암호화(키 교체)
svc2 = CredentialService(st, lambda: ring(2, APP_ENCRYPTION_KEY_V1=KEY1))
assert svc2.reencrypt_all() == {"reencrypted": 3, "failed": 0}
assert all(r["key_version"] == 2 for r in st.creds.values())
assert svc2.accessor("coupang").get("secret_key") == "SK-plain-222"
assert svc2.configured_codes(list(all_adapters()))["coupang"] is True
assert svc2.configured_codes(list(all_adapters()))["naver"] is False
assert svc2.configured_codes(list(all_adapters()))["cafe24"] is True # 공통 연동
# ════════════════════════════════════════════════════════════
# 동기화
# ════════════════════════════════════════════════════════════
class _Leaky(MarketplaceAdapter):
code, name = "coupang", "쿠팡"
def credential_fields(self):
return [CredentialField("secret_key", "Secret", secret=True)]
def collect(self, ctx, start, end):
secret = ctx.credentials.get("secret_key")
raise AuthFailed(f"401 invalid signature for key {secret} Authorization: CEA abcdefg123")
class _Good(MarketplaceAdapter):
code, name = "naver", "네이버"
def collect(self, ctx, start, end):
d = date(2026, 9, 29)
return 1, [
SaleEvent("SALE", "o1-S", "o1", d, 10_000, payment_date=d - timedelta(days=1), raw={"token": "t"}),
SaleEvent("CANCEL", "o1-C", "o1", d, -10_000),
]
def test_sync_isolation_redaction_and_dedupe():
import app.modules.performance.sync as syncmod
st = FakeStore()
creds = CredentialService(st, lambda: ring())
creds.save(_coupang(), {"vendor_id": "V", "access_key": "AK", "secret_key": "SUPER-SECRET-KEY-123"})
leaky, good = _Leaky(), _Good()
orig = syncmod.get_adapter
syncmod.get_adapter = lambda c: {"coupang": leaky, "naver": good}.get(c)
try:
svc = SyncService(st, creds)
r1 = svc.sync_marketplace("coupang", date(2026, 9, 23), date(2026, 9, 29))
r2 = svc.sync_marketplace("naver", date(2026, 9, 23), date(2026, 9, 29))
svc.sync_marketplace("naver", date(2026, 9, 23), date(2026, 9, 29)) # 두 번 = 중복 없음
finally:
syncmod.get_adapter = orig
assert not r1["ok"] and r1["status"] == "auth_failed"
assert "SUPER-SECRET-KEY-123" not in r1["message"] and "abcdefg123" not in r1["message"]
assert "SUPER-SECRET-KEY-123" not in st.status["coupang"]["error"]
assert r2["ok"] and r2["upserted"] == 2 and st.status["naver"]["status"] == "ok"
assert len([k for k in st.events if k[0] == "naver"]) == 2
sale = st.events[("naver", "SALE", "o1-S")]
assert sale["sales_date"] == date(2026, 9, 28) # 결제일 기준
assert st.events[("naver", "CANCEL", "o1-C")]["sales_date"] == date(2026, 9, 29) # 발생일 기준
assert sale["raw"]["token"] == MASK
# 이미 도는 중이면 건너뜀
st.running.add("naver")
syncmod.get_adapter = lambda c: good
try:
r3 = SyncService(st, creds).sync_marketplace("naver", date(2026, 9, 29), date(2026, 9, 29))
finally:
syncmod.get_adapter = orig
assert r3["skipped"]
def test_not_implemented_and_mock():
st = FakeStore()
creds = CredentialService(st, lambda: ring())
svc = SyncService(st, creds)
gm = next(a for a in all_adapters() if a.code == "gmarket")
r = svc.sync_marketplace("gmarket", date(2026, 9, 29), date(2026, 9, 29))
assert r["status"] == "not_configured" # 키 미입력
secret = next(f.key for f in gm.visible_fields() if f.secret)
creds.save(gm, {f.key: ("k-123456" if f.key == secret else "v") for f in gm.visible_fields()})
r = svc.sync_marketplace("gmarket", date(2026, 9, 29), date(2026, 9, 29))
assert r["status"] == "not_implemented" and "k-123456" not in r["message"]
import httpx
orig_get, httpx.get = httpx.get, (lambda url, headers=None, timeout=None: httpx.Response(200, content=b"<orders/>"))
try:
t = svc.test_connection("elevenst", values={"api_key": "typed-only"})
finally:
httpx.get = orig_get
assert t["unsaved"] and "test" not in st.status.get("elevenst", {}) # 저장 안 한 값 시험은 상태 기록 안 함
a = mock.generate("naver", date(2026, 9, 1), date(2026, 9, 30))
b = mock.generate("naver", date(2026, 9, 1), date(2026, 9, 30))
assert [e.amount for e in a] == [e.amount for e in b] and a
for e in a:
e.validate()
assert (e.amount < 0) == (e.event_type in ("CANCEL", "RETURN"))
assert any(e.event_type == "CANCEL" for e in a)
n = svc.generate_samples(date(2026, 9, 1), date(2026, 9, 30), ["naver"])
assert n == len(a) and all(v["is_sample"] for v in st.events.values())
assert sales_date_for(a[0]) == a[0].payment_date
assert event_row(a[0])["sales_date"] == a[0].payment_date
# ════════════════════════════════════════════════════════════
# 카페24 어댑터(가짜 API 응답) — 카페24 "일별 매출내역" 기준
# ════════════════════════════════════════════════════════════
# 마켓 통합관리 경로 시험용 매핑 — 실제 MARKET_MAP 은 비어 있다(이 쇼핑몰은 마켓 통합관리 미사용)
TEST_MARKET_MAP = {"shopn": "naver", "sk11st": "elevenst", "coupang": "coupang"}
def _with_markets(fn):
import functools
@functools.wraps(fn)
def run():
from app.modules.performance.adapters import cafe24 as c24
saved = dict(c24.MARKET_MAP)
c24.MARKET_MAP.update(TEST_MARKET_MAP)
try:
fn()
finally:
c24.MARKET_MAP.clear()
c24.MARKET_MAP.update(saved)
return run
def _c24_order(oid, market="self", paid="T", price=50_000, ship=3_000, coupon=5_000, member=1_000, items=2, **kw):
amt = {"order_price_amount": f"{price}.00", "shipping_fee": f"{ship}.00", "coupon_discount_price": f"{coupon}.00",
"membership_discount_amount": f"{member}.00", "points_spent_amount": "0.00",
"payment_amount": f"{price + ship - coupon - member}.00"}
return {"order_id": oid, "market_id": market, "paid": paid, "order_date": "2026-09-28T10:00:00+09:00",
"payment_date": "2026-09-29T11:21:35+09:00", "buyer_name": "홍길동", "receiver_address": "서울시",
"bank_account_no": "1234567890", "initial_order_amount": amt,
"actual_order_amount": {**amt, "order_price_amount": "0.00", "payment_amount": "0.00"}, # 취소 후 금액은 쓰지 않는다
"items": [{"order_item_code": f"{oid}-{i:02d}", "product_name": f"상품{i}", "quantity": 1}
for i in range(1, items + 1)], **kw}
def _c24_refund(code, oid, amount, status="T", order_date="2026-09-20T09:00:00+09:00"):
return {"refund_code": code, "order_id": oid, "order_date": order_date, "refund_date": "2026-09-29T17:31:50+09:00",
"actual_refund_amount": f"{amount}.00", "used_points": "0.00", "used_credits": "0.00", "quantity": 1,
"order_item_code": [f"{oid}-01"], "status": status, "refund_bank_account_no": "1234567890"}
class _FakeCafe24(__import__("app.modules.performance.adapters.cafe24", fromlist=["Cafe24Adapter"]).Cafe24Adapter):
def __init__(self, orders_pages, refunds_pages=(), lookup=None, claims=None):
self.orders_pages = orders_pages # 결제일 조회 페이지들
self.claims = claims or {} # date_type(취소/반품/교환 완료일) → 주문 목록
self.refunds_pages = list(refunds_pages)
self.lookup = lookup or {} # order_id → market_id (환불 원 주문 조회)
self.calls = []
def authenticate(self, ctx):
return None
def _get(self, ctx, path, params):
self.calls.append((path, params))
idx = params.get("offset", 0) // max(1, params.get("limit", 1))
if path == "/admin/refunds":
return {"refunds": self.refunds_pages[idx] if idx < len(self.refunds_pages) else []}
if params.get("date_type") == "order_date": # 원 주문 market_id 조회
ids = params["order_id"].split(",")
return {"orders": [{"order_id": i, "market_id": self.lookup.get(i, "self")} for i in ids]}
if params.get("date_type", "").endswith("_complete_date") or params.get("date_type") == "cancel_date":
return {"orders": self.claims.get(params["date_type"], []) if idx == 0 else []}
return {"orders": self.orders_pages[idx] if idx < len(self.orders_pages) else []}
@_with_markets
def test_cafe24_normalize_matches_daily_report():
from app.modules.performance.adapters.base import AdapterContext
from app.modules.performance.adapters.cafe24 import order_total, target_code
ctx = AdapterContext(code="cafe24", credentials=None)
fake = _FakeCafe24(
[[_c24_order("A", order_from_mobile="T", payment_method_name=["신용카드"]), _c24_order("B", market="shopn"),
_c24_order("C", paid="F"), _c24_order("D", market="auction", payment_method_name=["신용카드"]),
_c24_order("E", market="NCHECKOUT", payment_method_name=["네이버페이"]),
_c24_order("F", market="KAKAOPAY", payment_method_name=["카카오페이", "적립금"]),
_c24_order("G", market="mobile", order_from_mobile="T", payment_method_name=["무통장입금"])]],
[[_c24_refund("C20260929-01", "A", 12_610), _c24_refund("R20260929-02", "X", 20_000),
_c24_refund("C20260929-03", "M", 9_000), _c24_refund("C20260929-04", "A", 5_000, status="F")]],
lookup={"M": "shopn"},
)
fetched, events = fake.collect(ctx, date(2026, 9, 29), date(2026, 9, 29))
by = {(e.event_type, e.external_event_id): e for e in events}
# 결제합계 = 상품구매금액 + 배송비 − 할인 − 쿠폰 (결제 당시 금액), 사건 ID 는 c24: 접두어
sale = by[("SALE", "c24:A-PAY")]
assert sale.amount == 50_000 + 3_000 - 1_000 - 5_000 == 47_000 and sale.marketplace_code == "cafe24"
assert sale.event_date == date(2026, 9, 29) and sale.quantity == 2 and sale.product_name == "상품1 외 1건"
# 마켓 연동 주문은 해당 쇼핑몰 열로, 연결표에 없는 마켓(옥션)은 카페24 열, 미결제는 제외
assert by[("SALE", "c24:B-PAY")].marketplace_code == "naver"
assert by[("SALE", "c24:D-PAY")].marketplace_code == "cafe24"
# 네이버페이·톡체크아웃·모바일웹은 카페24 자체몰 주문(실데이터 확인) — 네이버/카카오 열로 가면 안 된다
for oid in ("E", "F", "G"):
assert by[("SALE", f"c24:{oid}-PAY")].marketplace_code == "cafe24", oid
assert ("SALE", "c24:C-PAY") not in by
# 환불: 환불완료일, 실제 환불액, R→반품 / 그 밖→취소, 원 주문의 마켓 열로, 미완료 환불 제외
assert by[("CANCEL", "c24:C20260929-01")].amount == -12_610
assert by[("CANCEL", "c24:C20260929-01")].marketplace_code == "cafe24"
assert by[("RETURN", "c24:R20260929-02")].amount == -20_000
assert by[("CANCEL", "c24:C20260929-03")].marketplace_code == "naver"
assert ("CANCEL", "c24:C20260929-04") not in by
assert by[("CANCEL", "c24:C20260929-01")].event_date == date(2026, 9, 29)
for e in events:
assert "buyer_name" not in str(e.raw) and "1234567890" not in str(e.raw) # 개인정보 미저장
assert order_total({"naver_point": "151500.00", # 9/23 화면값
"initial_order_amount": {"order_price_amount": "1860800.00", "shipping_fee": "35000.00",
"coupon_discount_price": "21000.00", "payment_amount": "1713128.00",
"points_spent_amount": "10110.00"}}) == 1_874_738
assert target_code("self") == "cafe24" and target_code("SK11ST") == "elevenst"
assert target_code("unknown", "coupang") == "coupang" and target_code("unknown") == "cafe24"
assert target_code("NCHECKOUT", "NCHECKOUT") == "cafe24" and target_code("KAKAOPAY") == "cafe24"
assert target_code("naver") == "cafe24" and target_code("kakao") == "cafe24" # 결제수단과 헷갈리는 일반 이름 X
# 대조: 카페24 열(자체몰 채널+모르는 채널)/다른 쇼핑몰 열 + 주문 채널별
import app.timezone as _tz
_orig_today, _tz.today_kst = _tz.today_kst, (lambda: date(2026, 9, 29))
try:
rec = fake.reconcile(ctx, date(2026, 9, 29))
finally:
_tz.today_kst = _orig_today
assert rec["orders"]["self"]["orders"] == 5 and rec["orders"]["self"]["total"] == 5 * 47_000 # A,D,E,F,G
assert rec["orders"]["market"]["orders"] == 1 and rec["unpaid_orders"] == 1 # B(스마트스토어)
assert rec["refunds"]["self"]["actual_refund_amount"] == 32_610 and rec["refunds"]["market"]["count"] == 1
ch = {b["market_id"]: b for b in rec["by_channel"]}
assert ch["shopn"]["kind"] == "market" and ch["shopn"]["target"] == "naver" and ch["shopn"]["refund_amount"] == 9_000
assert ch["auction"]["kind"] == "unknown" and ch["auction"]["target"] == "cafe24"
assert ch["NCHECKOUT"]["kind"] == "self" and ch["NCHECKOUT"]["label"] == "네이버페이"
assert ch["KAKAOPAY"]["label"] == "톡체크아웃" and ch["mobile"]["label"] == "모바일웹"
# 환불 기준 비교: 완료일(완료만) vs 접수일(전체 상태) — 가짜 API 는 두 기준에 같은 목록을 돌려준다
rb = rec["refund_basis"]
assert rb["completed"]["count"] == 3 and rb["completed"]["actual_refund_amount"] == 12_610 + 20_000 + 9_000
assert rb["accepted_all"]["count"] == 4 and rb["accepted_all"]["with_points"] == 12_610 + 20_000 + 9_000 + 5_000
assert {s["status"]: s["count"] for s in rb["accepted_by_status"]} == {"T": 3, "F": 1}
assert {c["key"] for c in rec["refund_candidates"]} >= {"completed", "completed_pts", "claim_pay"}
# 결제일 기준: 그날 결제된 카페24 열 주문(A,D,E,F,G)의 환불만 — X(결제 없음)·M(스마트스토어)·미완료 제외
bp = rec["refund_basis"]["by_pay_date"]
assert bp["count"] == 1 and bp["actual_refund_amount"] == 12_610
assert bp["amount_diff"] == 5 * 47_000 # 결제 당시 − 현재(가짜 현재 상품금액 0)
red = {x["order_id"]: x for x in rec["reduced_orders"]}
assert set(red) == {"A", "D", "E", "F", "G"} and red["A"]["refunded"] == 12_610 and red["D"]["refunded"] == 0
assert rec["reduced_orders"][-1]["order_id"] == "A" # 환불 기록으로 설명 안 되는 금액이 큰 순
assert {r["refund_code"] for r in rec["refund_list"]} == {"C20260929-01", "R20260929-02", "C20260929-03", "C20260929-04"}
assert "1234567890" not in str(rec["refund_list"]) # 환불 계좌 미노출
# 클레임 완료 품목: 환불 API 에 없는 취소(네이버페이 등)를 찾는다. 입금전취소·미완료는 합계 제외
item = lambda code, st, pay, price=10_000, qty=1: {"order_item_code": code, "order_status": st, "quantity": qty,
"product_price": f"{price}.00", "option_price": "0.00",
"payment_amount": f"{pay}.00", "product_name": "상품"}
fake4 = _FakeCafe24([[]], [[_c24_refund("C1", "A", 9_000)]], claims={
"cancel_complete_date": [
{**_c24_order("A"), "items": [item("A-01", "C40", 9_000)]},
{**_c24_order("N"), "market_id": "NCHECKOUT", "items": [item("N-01", "C40", 19_800, 20_000), item("N-02", "C40", 5_000, 5_000)]},
{**_c24_order("U"), "items": [item("U-01", "C48", 7_000)]},
{**_c24_order("P"), "items": [item("P-01", "C34", 3_000), item("P-02", "N40", 4_000)]}],
"return_complete_date": [{**_c24_order("N"), "items": [item("N-01", "C40", 19_800, 20_000)]},
{**_c24_order("R"), "items": [item("R-01", "R40", 12_000, 6_000, 2)]}],
})
rec4 = fake4.reconcile(ctx, date(2026, 9, 29))
cl = {c["item_code"]: c for c in rec4["claims"]["items"]}
assert set(cl) == {"A-01", "N-01", "N-02", "P-01", "R-01"} # 입금전취소(U)·정상 품목 제외, 중복 제거
assert cl["A-01"]["has_refund"] and not cl["N-01"]["has_refund"] and not cl["P-01"]["done"]
assert cl["R-01"]["product_amount"] == 12_000
assert rec4["claims"]["full_cancel_shipping"] == 3_000 * 2 # A, N 전체취소(배송비 3,000씩)
cand = {c["key"]: c["amount"] for c in rec4["refund_candidates"]}
assert cand["claim_pay"] == 9_000 + 19_800 + 5_000 + 12_000
assert cand["completed_plus_noref"] == 9_000 + 19_800 + 5_000 + 12_000
# 기기: PC 채널(self)이어도 휴대폰 주문(order_from_mobile=T)은 모바일
assert ch["self"]["mobile_orders"] == 1 and ch["self"]["pc_orders"] == 0 and ch["self"]["mobile_total"] == 47_000
assert ch["NCHECKOUT"]["pc_orders"] == 1 and ch["mobile"]["mobile_orders"] == 1
# self 는 PC 전용이 아니다 — 주문경로(PC쇼핑몰/모바일웹)별로 한 줄씩(실데이터 확인)
fake3 = _FakeCafe24([[_c24_order("P1", order_place_name="PC쇼핑몰"), _c24_order("P2", order_place_name="PC쇼핑몰"),
_c24_order("M1", order_place_name="모바일웹", order_from_mobile="T")]])
rows3 = {(b["market_id"], b["place"]): b for b in fake3.reconcile(ctx, date(2026, 9, 29))["by_channel"]}
assert rows3[("self", "PC쇼핑몰")]["orders"] == 2 and rows3[("self", "모바일웹")]["mobile_orders"] == 1
assert rows3[("self", "PC쇼핑몰")]["label"] == "자체몰"
# 결제수단별(카페24 열만 — 외부 마켓 B 제외)
pay = {p["method"]: p for p in rec["by_payment"]}
assert pay["신용카드"]["orders"] == 2 and pay["신용카드"]["total"] == 94_000
assert pay["카카오페이 + 적립금"]["orders"] == 1 and "네이버페이" in pay and "무통장입금" in pay
assert sum(p["orders"] for p in rec["by_payment"]) == 5
# 60일 단위 분할 + 페이지 넘김(1000건이면 다음 페이지)
page1 = [_c24_order(f"x-{i}") for i in range(1000)]
fake2 = _FakeCafe24([page1, [_c24_order("y")]])
got = list(fake2.paid_orders(ctx, date(2026, 7, 1), date(2026, 9, 30)))
calls = [p for path, p in fake2.calls if path == "/admin/orders"]
assert len(got) == 2002 # 60일 구간 2개 × (1000건 페이지 + 다음 페이지 1건)
assert calls[0]["start_date"] == "2026-07-01" and calls[0]["end_date"] == "2026-08-29"
assert calls[1]["offset"] == 1000 and all(c["limit"] == 1000 and c["date_type"] == "pay_date" for c in calls)
def test_cafe24_refund_total_includes_points_and_naverpay_cancels():
"""카페24 일별 매출 환불합계 = 환불 목록(실제 + 적립금·예치금) + 환불 목록에 없는 취소·반품(네이버페이 등).
실데이터: 9/26 = 178,220 + 1,080 + 네이버페이 취소 96,500 = 275,800, 9/27 = 145,000 + 네이버페이 55,800."""
import app.timezone as _tz
from app.modules.performance.adapters.base import AdapterContext
ctx = AdapterContext(code="cafe24", credentials=None)
item = lambda code, st, price, qty=1, day="2026-09-26 15:00:00", **kw: {
"order_item_code": code, "order_status": st, "quantity": qty, "product_price": f"{price}.00",
"option_price": "0.00", "product_name": "상품", "cancel_date": day, **kw}
refund = {**_c24_refund("C20260926-01", "O1", 63_720), "used_points": "1080.00",
"refund_date": "2026-09-26T20:25:08+09:00"}
fake = _FakeCafe24([[]], [[refund]], claims={
"cancel_date": [
{**_c24_order("O1"), "items": [item("O1-01", "C40", 64_800)]}, # 환불 목록 있음 → 제외
{**_c24_order("NP1", market="NCHECKOUT"), "items": [item("NP1-01", "C40", 55_800),
item("NP1-02", "N40", 9_000)]}, # 정상 품목 제외
{**_c24_order("NP2", market="NCHECKOUT"), "items": [item("NP2-01", "C40", 20_000, 2,
coupon_discount_price="1000.00")]},
{**_c24_order("NP3", market="NCHECKOUT"), "items": [item("NP3-01", "C40", 5_000, day="2026-09-27 01:00:00")]},
{**_c24_order("NP4", market="NCHECKOUT"), "items": [item("NP4-01", "C00", 5_000)]}, # 취소신청만 → 제외
# 전체취소 두 품목 — 배송비(3,000)는 마지막 품목(NP5-02)에 한 번만. 앞 품목은 전날 취소(기간 밖)
{**_c24_order("NP5", market="NCHECKOUT"), "items": [item("NP5-01", "C40", 7_000, day="2026-09-25 10:00:00"),
item("NP5-02", "C40", 8_000)]},
{**_c24_order("KP1", market="KAKAOPAY"), "items": [item("KP1-01", "C40", 9_900)]}, # 톡체크아웃 → 제외
{**_c24_order("S1"), "items": [item("S1-01", "R40", 9_900)]}, # 자체몰 → 제외
],
"return_complete_date": [{**_c24_order("NP1", market="NCHECKOUT"),
"items": [item("NP1-01", "C40", 55_800), item("NP1-02", "N40", 9_000)]}],
})
orig, _tz.today_kst = _tz.today_kst, (lambda: date(2026, 9, 29))
try:
_, events = fake.collect(ctx, date(2026, 9, 26), date(2026, 9, 26))
rec = fake.reconcile(ctx, date(2026, 9, 26))
finally:
_tz.today_kst = orig
by = {e.external_event_id: e for e in events if e.event_type != "SALE"}
assert by["c24:C20260926-01"].amount == -(63_720 + 1_080) # 적립금 환불 포함
assert by["c24:NP1-01-CL"].amount == -55_800 and by["c24:NP1-01-CL"].event_type == "CANCEL"
assert by["c24:NP1-01-CL"].event_date == date(2026, 9, 26) and by["c24:NP1-01-CL"].marketplace_code == "cafe24"
assert by["c24:NP2-01-CL"].amount == -(40_000 - 1_000 + 3_000) # 판매가×수량 − 품목 쿠폰 + 전체취소 배송비
assert by["c24:NP5-02-CL"].amount == -(8_000 + 3_000) # 배송비는 마지막 품목에 한 번
# 다른 날·신청·환불 기록 있는 주문·톡체크아웃·자체몰 제외
assert set(by) == {"c24:C20260926-01", "c24:NP1-01-CL", "c24:NP2-01-CL", "c24:NP5-02-CL"}
rs = rec["refunds"]["self"]
assert rs["no_record_count"] == 3 and rs["no_record"] == 55_800 + 42_000 + 11_000
assert rs["total"] == 63_720 + 1_080 + 55_800 + 42_000 + 11_000
cand = {c["key"]: c["amount"] for c in rec["refund_candidates"]}
assert cand["applied"] == rs["total"]
assert {c["item_code"] for c in rec["no_record_claims"]} == {"NP1-01", "NP2-01", "NP5-02"}
@_with_markets
def test_cafe24_scope_and_replace_range():
import app.modules.performance.sync as syncmod
from app.modules.performance.adapters.base import AdapterContext
from app.modules.performance.adapters.cafe24 import Cafe24Adapter
ctx = AdapterContext(code="cafe24", credentials=None)
real = Cafe24Adapter()
real.shared_status = lambda c: {"connected": True, "scopes": "mall.read_product,mall.write_product"}
try:
real.authenticate(ctx)
except AuthFailed as exc:
assert "mall.read_order" in exc.message
else:
raise AssertionError("주문 권한 없으면 인증 실패여야 합니다")
real.shared_status = lambda c: {"connected": True, "scopes": "mall.read_product,mall.read_order"}
real.authenticate(ctx)
def ev(eid, day, **kw):
return {"event_type": "SALE", "external_event_id": eid, "external_order_id": "o",
"event_date": day, "sales_date": day, "amount": 1, **kw}
# 기간 교체: 기간 안 카페24 행(예전 품목 단위)·카페24 경유 네이버 행은 지우고,
# 네이버 직접 연동분·테스트 데이터·기간 밖은 남긴다
st = FakeStore()
d, out = date(2026, 9, 29), date(2026, 9, 1)
st.upsert_events("cafe24", [ev("old-item-S", d), ev("outside", out)])
st.upsert_events("naver", [ev("c24:OLD-PAY", d), ev("direct-naver-1", d)])
st.upsert_events("cafe24", [ev("sample", d)], is_sample=True)
fake = _FakeCafe24([[_c24_order("A"), _c24_order("B", market="shopn")]])
orig = syncmod.get_adapter
syncmod.get_adapter = lambda c: fake
try:
r = SyncService(st, CredentialService(st, lambda: ring())).sync_marketplace("cafe24", d, d)
finally:
syncmod.get_adapter = orig
got = {(k[0], k[2]) for k in st.events}
assert r["ok"], r
assert got == {("cafe24", "c24:A-PAY"), ("naver", "c24:B-PAY"), ("cafe24", "outside"),
("naver", "direct-naver-1"), ("cafe24", "sample")}, got
def test_cafe24_paid_total_matches_daily_report():
"""카페24 결제합계 = 실결제금액 + 적립금 + 예치금 + 네이버포인트(결제 당시). 상품식과 다를 수 있다.
실데이터 9/23: 1,713,128 + 10,110 + 0 + 151,500 = 1,874,738 (상품식 1,874,800)."""
from app.modules.performance.adapters.cafe24 import order_total, order_total_now
o = _c24_order("A", naver_point="3000.00") # 상품식 50,000 + 3,000 − 1,000 − 5,000 = 47,000
o["initial_order_amount"].update(payment_amount="42938.00", points_spent_amount="1000.00")
assert order_total(o) == 42_938 + 1_000 + 3_000 == 46_938
ev = _FakeCafe24([]).normalize_order(o)[0]
assert ev.amount == 46_938 and ev.discount_amount == 1_000 + 5_000
o["actual_order_amount"] = {**o["initial_order_amount"], "payment_amount": "20000.00"}
assert order_total_now(o) == 20_000 + 1_000 + 3_000
z = _c24_order("Z")
z["initial_order_amount"]["payment_amount"] = "0.00"
assert order_total(z) == 0 # 결제 필드가 모두 0이면 카페24도 0원
# 대조 진단: 원본 금액 필드 합계 + 이상 주문(개인정보 숫자 필드는 제외)
import app.timezone as _tz
from app.modules.performance.adapters.base import AdapterContext
from app.modules.performance.adapters.cafe24 import money_fields
got = money_fields({"bank_account_no": "1234567890", "order_price_amount": "100.50", "x": {"coupon_discount_price": 3}})
assert got == {"order_price_amount": 101, "x.coupon_discount_price": 3}
o2 = _c24_order("B", price=10_050)
o2["items"] = [{"order_item_code": "B-01", "product_price": "10000.00", "option_price": "0", "quantity": 1,
"order_status": "N40"}]
orig, _tz.today_kst = _tz.today_kst, (lambda: date(2026, 9, 29))
try:
rec = _FakeCafe24([[o, o2]]).reconcile(AdapterContext(code="cafe24", credentials=None), date(2026, 9, 29))
finally:
_tz.today_kst = orig
assert rec["diag"]["order"]["naver_point"] == 3_000
assert rec["diag"]["initial"]["order_price_amount"] == 60_050 and "bank_account_no" not in rec["diag"]["order"]
odd = {x["order_id"]: x for x in rec["odd_orders"]}
assert odd["B"]["items_gross"] == 10_000 and odd["B"]["order_price_amount"] == 10_050
@_with_markets
def test_daily_check_db_vs_live():
"""일별 비교: 저장값(카페24 경유 다른 마켓 열 포함) + 지금 API 값(저장 안 함)."""
import app.modules.performance.sync as syncmod
st = FakeStore()
d = date(2026, 9, 29)
ev = lambda eid, t, amt, **kw: {"event_type": t, "external_event_id": eid, "external_order_id": "o",
"event_date": d, "sales_date": d, "amount": amt, **kw}
st.upsert_events("cafe24", [ev("c24:A-PAY", "SALE", 40_000), ev("c24:R1", "CANCEL", -5_000)])
st.upsert_events("naver", [ev("c24:B-PAY", "SALE", 10_000), ev("direct-1", "SALE", 99_999)])
fake = _FakeCafe24([[_c24_order("A"), _c24_order("B", market="shopn"), _c24_order("C")]],
[[_c24_refund("C20260929-01", "A", 7_000)]])
orig = syncmod.get_adapter
syncmod.get_adapter = lambda c: fake
try:
svc = SyncService(st, CredentialService(st, lambda: ring()))
only_db = svc.daily_check("cafe24", d, d)
both = svc.daily_check("cafe24", d, d, live=True)
finally:
syncmod.get_adapter = orig
assert "live" not in only_db
assert both["db"] == [{"date": "2026-09-29", "paid": 50_000, "orders": 2, "refund": 5_000, "synced_at": None}]
assert both["live"] == [{"date": "2026-09-29", "paid": 3 * 47_000, "orders": 3, "refund": 7_000}]
assert len(st.events) == 4 # 저장값은 바뀌지 않음
def test_cafe24_market_map_empty_by_default():
"""마켓 통합관리 미사용 — 카페24로 들어온 주문은 market_id 가 무엇이든 카페24 열."""
from app.modules.performance.adapters.cafe24 import MARKET_MAP, target_code
assert MARKET_MAP == {}
assert target_code("shopn") == target_code("coupang", "coupang") == target_code("NCHECKOUT") == "cafe24"
def test_coupang_hmac_and_connection_errors():
"""쿠팡 CEA HMAC 서명(공식 예제 방식) + 연결 테스트 오류 구분. 비밀값은 메시지에 없다."""
import hashlib
import hmac as _hmac
import httpx
from app.modules.performance.adapters import coupang as cp
from app.modules.performance.adapters.base import AdapterContext
q = cp.build_query({"createdAtFrom": "2026-09-30+09:00", "status": "ACCEPT", "maxPerPage": 1})
assert q == "createdAtFrom=2026-09-30%2B09:00&status=ACCEPT&maxPerPage=1"
now = 1_790_000_000 # 2026-09-21 14:13:20 UTC
h = cp.authorization("GET", "/p", q, "AK", "SK", now=now)
dt = "260921T141320Z"
sig = _hmac.new(b"SK", f"{dt}GET/p{q}".encode(), hashlib.sha256).hexdigest()
assert h == f"CEA algorithm=HmacSHA256, access-key=AK, signed-date={dt}, signature={sig}"
class Creds(dict):
def get(self, k, default=""):
return dict.get(self, k, default)
def has(self, k):
return bool(dict.get(self, k))
ctx = AdapterContext(code="coupang", credentials=Creds(vendor_id="A00012345", access_key="AK-1", secret_key="SK-SECRET"))
seen = {}
def fake_get(url, headers=None, timeout=None, status=200, body=None):
seen["url"], seen["auth"] = url, headers["Authorization"]
return httpx.Response(status, json=body if body is not None else {"code": 200, "data": []})
orig = httpx.get
try:
httpx.get = fake_get
msg = cp.CoupangAdapter().test_connection(ctx)
assert "연결 정상" in msg and "/vendors/A00012345/ordersheets?createdAtFrom=" in seen["url"]
assert "%2B09:00" in seen["url"] and "SK-SECRET" not in seen["auth"]
httpx.get = lambda url, headers=None, timeout=None: fake_get(url, headers, timeout, 403, {"message": "Access Denied"})
try:
cp.CoupangAdapter().test_connection(ctx)
except AuthFailed as exc:
assert "403" in exc.message and "자체개발" in exc.message and "SK-SECRET" not in exc.message
else:
raise AssertionError("403 이면 인증 실패여야 합니다")
finally:
httpx.get = orig
def test_elevenst_connection():
"""11번가: openapikey 헤더 + 결제완료 주문 조회(XML). 오류 코드·403 구분, 키는 메시지에 없음."""
import httpx
from app.modules.performance.adapters import elevenst as ev
from app.modules.performance.adapters.base import AdapterContext
class Creds(dict):
def get(self, k, default=""):
return dict.get(self, k, default)
def has(self, k):
return bool(dict.get(self, k))
ctx = AdapterContext(code="elevenst", credentials=Creds(api_key="KEY-11ST-SECRET"))
seen = {}
ok_xml = ('<?xml version="1.0" encoding="euc-kr"?><ns2:orders xmlns:ns2="http://skt.tmall.business.openapi.spring.service.'
'client.domain/"><ns2:order><ordNo>1</ordNo></ns2:order><ns2:order><ordNo>2</ordNo></ns2:order>'
'</ns2:orders>').encode("euc-kr")
def fake(status, content):
def get(url, headers=None, timeout=None):
seen["url"], seen["key"] = url, headers["openapikey"]
return httpx.Response(status, content=content)
return get
orig = httpx.get
try:
httpx.get = fake(200, ok_xml)
msg = ev.ElevenstAdapter().test_connection(ctx)
assert "연결 정상" in msg and "2건" in msg and seen["key"] == "KEY-11ST-SECRET"
assert "/rest/ordservices/complete/" in seen["url"]
err = '<ns2:orders xmlns:ns2="x"><ns2:result_code>-1</ns2:result_code><ns2:result_text>허용되지 않은 IP</ns2:result_text></ns2:orders>'
for status, body, kind in ((200, err.encode(), ApiError), (403, b"Forbidden", AuthFailed),
(200, b"<html><body>IP not allowed</body></html>", ApiError)):
httpx.get = fake(status, body)
try:
ev.ElevenstAdapter().test_connection(ctx)
except kind as exc:
assert "KEY-11ST-SECRET" not in exc.message
assert status == 403 or "허용되지 않은 IP" in exc.message or "XML 아님" in exc.message
else:
raise AssertionError("오류여야 합니다")
# 원본 데이터 확인: 살아 있는 주소는 항목 합계, 없는 주소(404)는 실패로. 개인정보 값은 숨김
rows = ("<ns2:orders xmlns:ns2='x'>" + "".join(
f"<ns2:order><ordNo>{n}</ordNo><ordPayAmt>{a}</ordPayAmt><rcvrNm>홍길동</rcvrNm><prdNm>상품{n}</prdNm>"
f"<ordStlEndDt>2026-09-29 10:00:00</ordStlEndDt></ns2:order>" for n, a in ((1, 10000), (2, 5500))) +
"</ns2:orders>").encode()
def route(url, headers=None, timeout=None):
if "/ordservices/complete/" in url:
return httpx.Response(200, content=rows)
if "/ordservices/purchaseconfirm/" in url:
return httpx.Response(404, content=b"<html>not found</html>")
if "/ordservices/" in url:
return httpx.Response(200, content=b"<ns2:orders xmlns:ns2='x'/>")
if "/claimservice/" in url:
return httpx.Response(200, content="<ns2:orders xmlns:ns2='x'><ns2:result_code>-1</ns2:result_code>"
"<ns2:result_text>해당 건이 없습니다.</ns2:result_text></ns2:orders>".encode())
return httpx.Response(404, content=b"<html>not found</html>")
httpx.get = route
rec = ev.ElevenstAdapter().reconcile(ctx, date(2026, 9, 29))
wide = ev.ElevenstAdapter().reconcile(ctx, date(2026, 9, 1), to=date(2026, 9, 20)) # 7일씩 3번
assert wide["to"] == "2026-09-20" and {p["key"]: p.get("count") for p in wide["probes"]}["complete"] == 6
by = {p["key"]: p for p in rec["probes"]}
assert by["complete"]["ok"] and by["complete"]["count"] == 2 and by["shipping"]["count"] == 0
assert not by["purchaseconfirm"]["ok"] and "404" in by["purchaseconfirm"]["error"]
assert by["canceledorders"]["ok"] and by["canceledorders"]["count"] == 0 # 코드 -1 "해당 건이 없습니다" = 0건
f = {x["name"]: x for x in by["complete"]["fields"]}
assert f["ordPayAmt"]["sum"] == 15_500 and f["rcvrNm"]["personal"] and f["rcvrNm"]["sample"] == ""
assert f["prdNm"]["sample"] == "상품1" and "홍길동" not in repr(rec)
finally:
httpx.get = orig
def test_elevenst_collect_sales():
"""11번가 매출 = 주문 단위, 결제일 기준.
정산된 주문은 정산 내역의 판매금액합계(selPrcAmt) 합 — 셀러오피스 "판매 상세내역"과 같다(배송비 줄 포함).
정산 전 주문은 주문 상태 목록의 ordAmt + 배송비. 실데이터: 9/9 = 34,900, 9/10 = 83,800 + 배송비 3,000 = 86,800
(주문 목록의 dlvCst 는 0 이라 정산 값을 써야 맞음)."""
import httpx
import app.modules.performance.sync as syncmod # noqa: F401
import app.timezone as _tz
def line(no, seq, day, amt, pay, ship=0, qty=1):
return (f"<ns2:order><ordNo>{no}</ordNo><ordPrdSeq>{seq}</ordPrdSeq><ordDt>{day} 15:13:16</ordDt>"
f"<ordAmt>{amt}</ordAmt><ordPayAmt>{pay}</ordPayAmt><dlvCst>{ship}</dlvCst><ordQty>{qty}</ordQty>"
f"<prdNm>밀폐용기</prdNm><rcvrNm>홍길동</rcvrNm><memNo>18550503</memNo></ns2:order>")
def stl(no, pay_day, amt, qty, cupn=0):
return (f"<ns2:settlement><ordNo>{no}</ordNo><ordPrdSeq>1</ordPrdSeq><memNm>홍길동</memNm>"
f"<ordStlEndDt>{pay_day}</ordStlEndDt><stlDy>2026/09/19</stlDy><prdNm>밀폐용기</prdNm><ordQty>{qty}</ordQty>"
f"<selPrcAmt>{amt}</selPrcAmt><stlAmt>{amt - 100}</stlAmt><cupnAmt>{cupn}</cupnAmt></ns2:settlement>")
settlement = ("<ns2:settlements xmlns:ns2='x'>" + stl("20260909099415322", "2026/09/09", 34900, 1) +
stl("20260910099718265", "2026/09/10", 3000, 0) + stl("20260910099718265", "2026/09/10", 83800, 2, 11060) +
stl("20260801000000009", "2026/08/01", 9999, 1) + "</ns2:settlements>").encode()
completed = ("<ns2:orders xmlns:ns2='x'>" + line("20260909099415322", 1, "2026-09-09", 34900, 34900) +
line("20260910099718265", 1, "2026-09-10", 83800, 72740, qty=2) +
line("20260801000000001", 1, "2026-08-01", 5000, 5000) + "</ns2:orders>").encode()
packaging = ("<ns2:orders xmlns:ns2='x'>" + line("20260911000000002", 1, "2026-09-11", 20000, 20000, ship=3000) +
line("20260911000000002", 2, "2026-09-11", 5000, 5000, ship=3000) +
line("20260911000000002", 2, "2026-09-11", 5000, 5000, ship=3000) + "</ns2:orders>").encode()
empty = "<ns2:orders xmlns:ns2='x'><ns2:result_code>-1</ns2:result_code><ns2:result_text>해당 건이 없습니다.</ns2:result_text></ns2:orders>".encode()
calls = []
def route(url, headers=None, timeout=None):
calls.append(url)
if "/settlement/" in url:
return httpx.Response(200, content=settlement if "/20260916/" in url else empty)
if "/ordservices/completed/" in url:
return httpx.Response(200, content=completed)
if "/ordservices/packaging/" in url:
return httpx.Response(200, content=packaging)
return httpx.Response(200, content=empty)
st = FakeStore()
creds = CredentialService(st, lambda: ring())
creds.save(next(a for a in all_adapters() if a.code == "elevenst"), {"api_key": "KEY-11ST"})
orig, orig_today = httpx.get, _tz.today_kst
httpx.get, _tz.today_kst = route, (lambda: date(2026, 9, 30))
try:
r = SyncService(st, creds).sync_marketplace("elevenst", date(2026, 9, 9), date(2026, 9, 11))
finally:
httpx.get, _tz.today_kst = orig, orig_today
assert r["ok"], r
ev_ = {k[2]: v for k, v in st.events.items() if k[0] == "elevenst"}
assert set(ev_) == {"11st:20260909099415322", "11st:20260910099718265", "11st:20260911000000002"} # 8/1 제외
assert ev_["11st:20260909099415322"]["amount"] == 34_900 and ev_["11st:20260909099415322"]["sales_date"] == date(2026, 9, 9)
assert ev_["11st:20260910099718265"]["amount"] == 86_800 # 정산 값(배송비 줄 포함)
assert ev_["11st:20260910099718265"]["discount_amount"] == 11_060 and ev_["11st:20260910099718265"]["quantity"] == 2
assert ev_["11st:20260910099718265"]["order_status"] == "정산확정"
assert ev_["11st:20260911000000002"]["amount"] == 25_000 + 3_000 # 정산 전: ordAmt + 배송비 한 번, 중복 줄 1번
assert ev_["11st:20260911000000002"]["order_status"] == "발송대기"
assert "홍길동" not in repr(st.events) and "18550503" not in repr(st.events) # 구매자 정보 미저장
assert any("/20260930" in u for u in calls) and not any("/20261001" in u for u in calls) # 오늘까지만 더 불러옴
def test_registry_and_event_validation():
codes = [a.code for a in all_adapters()]
assert len(codes) == len(set(codes)) == 10
for a in all_adapters():
keys = [f.key for f in a.credential_fields()]
assert len(keys) == len(set(keys)), a.code
assert a.uses_shared_integration or any(f.secret for f in a.visible_fields()), a.code
for bad in (SaleEvent("SALE", "x", "o", date.today(), -1), SaleEvent("CANCEL", "x", "o", date.today(), 5),
SaleEvent("SALE", "x", "o", date.today(), 1.5), SaleEvent("BOGUS", "x", "o", date.today(), 1)):
try:
bad.validate()
except ValueError:
pass
else:
raise AssertionError(f"검증 실패해야 함: {bad.event_type} {bad.amount}")
def _naver_item(order_id, po_id, pay_day, amount, *, status="PAYED", ship=0, ship_dc=0, qty=1, dc=0, name="밀폐용기"):
"""조건형 상품 주문 조회 응답의 contents[] 한 줄(개인정보 항목 포함 — 저장 안 되는지 확인용)."""
return {"productOrderId": po_id, "content": {
"order": {"orderId": order_id, "paymentDate": f"{pay_day}T10:11:12.0+09:00", "orderDate": f"{pay_day}T10:10:00.0+09:00",
"ordererName": "홍길동", "ordererTel": "010-1234-5678", "ordererId": "hong***"},
"productOrder": {"productOrderId": po_id, "productOrderStatus": status, "productName": name, "productOption": "3개입",
"quantity": qty, "totalPaymentAmount": amount, "productDiscountAmount": dc,
"deliveryFeeAmount": ship, "deliveryDiscountAmount": ship_dc,
"shippingAddress": {"name": "홍길동", "tel1": "010-1234-5678", "baseAddress": "서울시 어딘가"}},
}}
def test_naver_sign_token_and_connection():
"""네이버: bcrypt 전자서명 → 토큰(form) → Bearer 로 조건형 주문 조회. 시크릿·토큰은 오류 문구에 없음."""
import base64
import bcrypt
import httpx
from app.modules.performance.adapters import naver as nv
from app.modules.performance.adapters.base import AdapterContext
secret = bcrypt.gensalt(rounds=4).decode()
sig = nv.sign("my-app-id", secret, 1727600000000)
assert bcrypt.checkpw(b"my-app-id_1727600000000", base64.b64decode(sig))
try:
nv.sign("my-app-id", "not-a-bcrypt-salt", 1)
except AuthFailed as exc:
assert "not-a-bcrypt-salt" not in exc.message
else:
raise AssertionError("시크릿 형식 오류여야 합니다")
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
ctx = AdapterContext(code="naver", credentials=Creds(client_id="my-app-id", client_secret=secret))
seen = {"gets": []}
def post(url, data=None, timeout=None, headers=None):
seen["post"] = (url, dict(data))
return httpx.Response(200, json={"access_token": "TOKEN-XYZ", "expires_in": 10799, "token_type": "Bearer"})
def get(url, params=None, headers=None, timeout=None):
seen["gets"].append((url, dict(params), headers["Authorization"]))
return httpx.Response(200, json={"data": {"contents": [_naver_item("O1", "P1", "2026-09-30", 12000)],
"pagination": {"page": 1, "size": 100, "hasNext": False}}})
orig = (httpx.post, httpx.get, nv.CALL_INTERVAL_SEC)
httpx.post, httpx.get, nv.CALL_INTERVAL_SEC = post, get, 0
try:
msg = nv.NaverAdapter().test_connection(ctx)
assert "연결 정상" in msg and "1건" in msg
url, form = seen["post"]
assert url.endswith("/external/v1/oauth2/token") and form["type"] == "SELF" and form["grant_type"] == "client_credentials"
assert bcrypt.checkpw(f"my-app-id_{form['timestamp']}".encode(), base64.b64decode(form["client_secret_sign"]))
gurl, params, auth = seen["gets"][0]
assert gurl.endswith("/v1/pay-order/seller/product-orders") and auth == "Bearer TOKEN-XYZ"
assert params["rangeType"] == "PAYED_DATETIME" and params["from"].endswith("T00:00:00.000+09:00")
assert params["to"].endswith("T23:59:59.999+09:00") and params["from"][:10] == params["to"][:10]
assert ctx.credentials["access_token"] == "TOKEN-XYZ" and int(ctx.credentials["access_token_expires_at"]) > 0
# 토큰 발급 거부 → 인증 실패(시크릿·서명은 문구에 없음)
httpx.post = lambda url, data=None, timeout=None, headers=None: httpx.Response(
400, json={"code": "BadRequest", "message": "client_secret_sign 이 올바르지 않습니다"})
try:
nv.NaverAdapter().test_connection(ctx)
except AuthFailed as exc:
assert secret not in exc.message and "올바르지 않습니다" in exc.message
else:
raise AssertionError("인증 실패여야 합니다")
# 주문 조회 403(IP 미등록 등) → 인증 실패 안내
httpx.post = post
httpx.get = lambda url, params=None, headers=None, timeout=None: httpx.Response(
403, json={"code": "GW.IP_NOT_ALLOWED", "message": "허용되지 않은 IP"})
try:
nv.NaverAdapter().test_connection(ctx)
except AuthFailed as exc:
assert "허용되지 않은 IP" in exc.message and "TOKEN-XYZ" not in exc.message
else:
raise AssertionError("권한 거부여야 합니다")
finally:
httpx.post, httpx.get, nv.CALL_INTERVAL_SEC = orig
def test_naver_collect_sales():
"""네이버 매출 = 판매분석 "판매금액(총)" — 주문 단위, 결제일 기준, 상품주문 결제금액 합(배송비 제외).
결제 뒤 취소·반품된 것도 포함, 미입금 취소만 뺀다(9/1 실데이터: 판매금액(총) 4,455,600, 배송비 별도).
페이지를 넘겨 받고, 구매자 정보는 저장하지 않는다."""
import bcrypt
import httpx
from app.modules.performance.adapters import naver as nv
pages = {
("2026-09-09", 1): ([_naver_item("A", "A1", "2026-09-09", 20000, ship=3000, qty=2, dc=1000),
_naver_item("A", "A2", "2026-09-09", 5000, ship=3000, name="뚜껑")], True),
("2026-09-09", 2): ([_naver_item("B", "B1", "2026-09-09", 9900, status="CANCELED")], False),
("2026-09-10", 1): ([_naver_item("C", "C1", "2026-09-10", 15000, ship=3000, ship_dc=3000, status="PURCHASE_DECIDED"),
_naver_item("C", "C2", "2026-09-10", 7000, status="RETURNED"),
_naver_item("D", "D1", "2026-09-10", 4000, status="CANCELED_BY_NOPAYMENT")], False),
}
calls = []
def get(url, params=None, headers=None, timeout=None):
key = (params["from"][:10], params["page"])
calls.append(key)
rows, more = pages.get(key, ([], False))
return httpx.Response(200, json={"data": {"contents": rows, "pagination": {"page": params["page"], "hasNext": more}}})
def post(url, data=None, timeout=None, headers=None):
return httpx.Response(200, json={"access_token": "TOKEN-N", "expires_in": 10799})
st = FakeStore()
creds = CredentialService(st, lambda: ring())
creds.save(next(a for a in all_adapters() if a.code == "naver"),
{"client_id": "app-id", "client_secret": bcrypt.gensalt(rounds=4).decode()})
orig = (httpx.post, httpx.get, nv.CALL_INTERVAL_SEC)
httpx.post, httpx.get, nv.CALL_INTERVAL_SEC = post, get, 0
try:
r = SyncService(st, creds).sync_marketplace("naver", date(2026, 9, 9), date(2026, 9, 10))
finally:
httpx.post, httpx.get, nv.CALL_INTERVAL_SEC = orig
assert r["ok"], r
ev_ = {k[2]: v for k, v in st.events.items() if k[0] == "naver"}
assert set(ev_) == {"naver:A", "naver:B", "naver:C"} # D 미입금취소만 제외
assert ev_["naver:A"]["amount"] == 20000 + 5000 # 배송비 제외
assert ev_["naver:B"]["amount"] == 9900 # 결제 뒤 취소도 결제일 매출(판매금액(총))
assert ev_["naver:A"]["quantity"] == 3 and ev_["naver:A"]["discount_amount"] == 1000
assert ev_["naver:A"]["sales_date"] == date(2026, 9, 9) and ev_["naver:A"]["product_name"] == "밀폐용기 외 1건"
assert ev_["naver:C"]["amount"] == 15000 + 7000 # 반품 줄도 포함
assert ev_["naver:C"]["order_status"] == "구매확정/반품"
assert ("2026-09-09", 2) in calls and ("2026-09-10", 2) not in calls # hasNext 일 때만 다음 쪽
assert "홍길동" not in repr(st.events) and "010-1234-5678" not in repr(st.events)
def test_naver_reconcile_hides_personal():
import httpx
from app.modules.performance.adapters import naver as nv
from app.modules.performance.adapters.base import AdapterContext
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
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)))
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(
200, json={"data": {"contents": rows if params["from"].startswith("2026-09-09") else []}})
nv.CALL_INTERVAL_SEC = 0
try:
rec = nv.NaverAdapter().reconcile(ctx, date(2026, 9, 9), to=date(2026, 9, 10))
finally:
httpx.get, nv.CALL_INTERVAL_SEC = orig
allp = rec["probes"][0]
assert allp["ok"] and allp["count"] == 2
f = {x["name"]: x for x in allp["fields"]}
assert f["productOrder.totalPaymentAmount"]["sum"] == 29900
assert f["order.ordererName"]["personal"] and f["order.ordererName"]["sample"] == ""
assert f["productOrder.shippingAddress.baseAddress"]["personal"]
assert not f["productOrder.productName"]["personal"] and f["productOrder.productName"]["sample"] == "밀폐용기"
assert "홍길동" not in repr(rec) and "010-1234-5678" not in repr(rec)
assert rec["days"] == [{"date": "2026-09-09", "orders": 2, "amount": 29900, "claimed": 9900, "ship": 3000},
{"date": "2026-09-10", "orders": 0, "amount": 0, "claimed": 0, "ship": 0}]
assert any("결제 뒤 취소·반품(매출 포함)" in p["label"] for p in rec["probes"])
def test_sync_job_progress():
"""매출 업데이트 진행 창: 쇼핑몰별 단계(네이버 = 일)·받은 건수·상태, 전체 진행률.
수집이 없는 쇼핑몰(연동 준비 중)·인증정보 없는 쇼핑몰은 막대에서 빼고(active=False) 전체 진행률에 넣지 않는다."""
import bcrypt
import httpx
from app.modules.performance import jobs
from app.modules.performance.adapters import naver as nv
mid = {}
job = jobs.create_job(user="king@x", start=None, end=None)
def get(url, params=None, headers=None, timeout=None):
day = params["from"][:10]
if day == "2026-09-10": # 둘째 날을 받는 중 — 진행 상황 중간 모습
mid.update(job.snapshot())
rows = [_naver_item("A" + day, "P" + day, day, 10000), _naver_item("B" + day, "Q" + day, day, 5000)]
return httpx.Response(200, json={"data": {"contents": rows, "pagination": {"hasNext": False}}})
st = FakeStore()
st.markets = [m for m in st.markets if m["code"] in ("naver", "ohouse", "elevenst")]
creds = CredentialService(st, lambda: ring())
creds.save(next(a for a in all_adapters() if a.code == "naver"),
{"client_id": "app-id", "client_secret": bcrypt.gensalt(rounds=4).decode()})
orig = (httpx.post, httpx.get, nv.CALL_INTERVAL_SEC)
httpx.post = lambda url, data=None, timeout=None, headers=None: httpx.Response(200, json={"access_token": "T", "expires_in": 10799})
httpx.get, nv.CALL_INTERVAL_SEC = get, 0
try:
SyncService(st, creds).sync_all(start=date(2026, 9, 9), end=date(2026, 9, 10), user="king@x", job=job)
finally:
httpx.post, httpx.get, nv.CALL_INTERVAL_SEC = orig
job.finish(last_update_at="2026-09-30T10:00:00")
m = {s["code"]: s for s in mid["shops"]}
assert m["naver"]["state"] == "running" and (m["naver"]["done"], m["naver"]["total"], m["naver"]["unit"]) == (1, 2, "일")
assert m["naver"]["items"] == 2 and m["naver"]["fraction"] == 0.5
assert mid["overall"]["shops"] == 1 and mid["overall"]["fraction"] == 0.5 and not mid["finished"]
snap = job.snapshot()
s = {x["code"]: x for x in snap["shops"]}
assert s["naver"]["state"] == "done" and s["naver"]["upserted"] == 4 and s["naver"]["items"] == 4
assert s["naver"]["done"] == s["naver"]["total"] == 2 and s["naver"]["fraction"] == 1.0
assert s["ohouse"]["state"] == "error" and s["ohouse"]["status"] in ("not_implemented", "not_configured")
assert not s["ohouse"]["active"]
assert s["elevenst"]["state"] == "error" and s["elevenst"]["status"] == "not_configured" and not s["elevenst"]["active"]
assert snap["finished"] and snap["overall"] == {"shops": 1, "finished": 1, "fraction": 1.0, "items": 4, "upserted": 4}
assert snap["from"] == "2026-09-09" and snap["to"] == "2026-09-10"
assert jobs.get_job(job.id) is job and jobs.running_job() is None
def test_gsshop_token_connection_and_probe():
"""GS샵: token = AES256(yyyyMMddHHmmss + 협력사코드), 헤더 supCd·token. 암호화 모드를 모르니 순서대로 시도해
통과한 모드를 기억. 인증 오류는 HTTP 200 + result=fail/code 401. 원본 확인은 10일씩·쪽 넘김, 키는 문구에 없음."""
import base64
from datetime import datetime
import httpx
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from app.modules.performance.adapters import gsshop as gs
from app.modules.performance.adapters.base import AdapterContext
key = "0123456789abcdef0123456789ABCDEF" # 32바이트 = AES256
def decrypt(tok, mode):
m = {"ecb": modes.ECB(), "cbc-zeroiv": modes.CBC(b"\0" * 16)}.get(mode, modes.CBC(key.encode()[:16]))
d = Cipher(algorithms.AES(key.encode()), m).decryptor()
raw = d.update(base64.b64decode(tok)) + d.finalize()
u = padding.PKCS7(128).unpadder()
return (u.update(raw) + u.finalize()).decode()
# 키 변형: 32자 16진수 → 글자 그대로(AES256) + 16진수 풀기(16바이트), 64자 16진수 → 풀어서 32바이트 + 앞 32자
hex32 = "af3df6c96b92f9166fd75b80006c6812"
assert [v for v, _ in gs.key_variants(hex32)] == ["text", "hex"]
assert [(v, len(b)) for v, b in gs.key_variants(hex32 * 2)] == [("hex", 32), ("first32", 32)]
now = datetime(2018, 10, 17, 17, 49, 13)
for mode in gs.TOKEN_MODES:
assert decrypt(gs.make_token(key, "1036018", now, mode), mode) == "201810171749131036018"
try:
gs.make_token("short-key", "1", now, "ecb")
except AuthFailed as exc:
assert "short-key" not in exc.message
else:
raise AssertionError("키 길이 오류여야 합니다")
class Creds(dict):
def get(self, k, default=""):
return dict.get(self, k, default)
def has(self, k):
return bool(dict.get(self, k))
ctx = AdapterContext(code="gsshop", credentials=Creds(vendor_code="1036018", api_key=key))
calls = []
def get(url, params=None, headers=None, timeout=None):
assert headers["supCd"] == "1036018" and params["supCode"] == "1036018"
# 서버는 ECB 로 풀어 본다고 가정 — CBC 토큰은 거부(HTTP 200 + result=fail)
try:
plain = decrypt(headers["token"], "ecb")
except Exception: # noqa: BLE001
plain = ""
if not plain.endswith("1036018"):
return httpx.Response(200, json={"result": "fail", "message": "키 인증 중 오류가 발생하였습니다.", "code": "401 UNAUTHORIZED"})
calls.append((url, dict(params)))
if url.endswith("/sales"):
return httpx.Response(200, json={"data": [], "hasMorePage": False, "totalCount": 3})
page = params["pageIdx"]
more = url.endswith("/sales/period") and params["fromDate"] == "20260901" and page == 1
rows = [{"ordNo": f"{params['fromDate']}-{page}", "saleAmt": 10000, "custNm": "홍길동", "prdNm": "밀폐용기"}]
return httpx.Response(200, json={"data": rows, "hasMorePage": more, "totalCount": 2 if more else 1})
orig = httpx.get
httpx.get = get
try:
msg = gs.GsshopAdapter().test_connection(ctx)
assert "연결 정상" in msg and "3건" in msg and "ECB" in msg
adapter = gs.GsshopAdapter()
rec = adapter.reconcile(ctx, date(2026, 9, 1), to=date(2026, 9, 15)) # 10일 + 5일
sales, ship = rec["probes"]
assert sales["ok"] and sales["count"] == 3 and ship["ok"] and ship["count"] == 2 # 9/1 두 쪽 + 9/11
f = {x["name"]: x for x in sales["fields"]}
assert f["saleAmt"]["sum"] == 30000 and f["custNm"]["personal"] and f["custNm"]["sample"] == ""
assert f["prdNm"]["sample"] == "밀폐용기" and "홍길동" not in repr(rec)
periods = {(p["fromDate"], p["toDate"]) for u, p in calls if u.endswith("/sales/period")}
assert periods == {("20260901", "20260910"), ("20260911", "20260915")}
# 틀린 키 → 세 가지 모드 모두 거부 → 인증 실패(키는 문구에 없음)
bad = AdapterContext(code="gsshop", credentials=Creds(vendor_code="1036018", api_key="X" * 32))
try:
gs.GsshopAdapter().test_connection(bad)
except AuthFailed as exc:
assert "X" * 32 not in exc.message and "3가지" in exc.message # 32자 글자 키 → 모드 3가지
else:
raise AssertionError("인증 실패여야 합니다")
finally:
httpx.get = orig
def test_gsshop_collect_sales():
"""GS샵 매출 = 매출 내역 supGiveAmt(협력사 지급액 = 포털 주문 통계 금액), 매출인식일 기준, 배송비 제외.
SALE 이 아닌 줄은 음수(RETURN). 실데이터 9/3: 판매가 16,400 → 지급액 13,940(85%), 고객 결제 15,580."""
import httpx
from app.modules.performance.adapters import gsshop as gs
key = "0123456789abcdef0123456789ABCDEF"
def line(no, item, day, sale, dc, typ="SALE", qty=1):
return {"rnum": 1, "saleAwareDt": day, "prdCd": 1064149860, "prdNm": "미라클통 황토 3200ml", "supCd": 1047142,
"ordNo": no, "ordItemNo": item, "orgOrdNo": no, "ordType": typ, "chrQty": qty, "salePrice": sale,
"dcTotAmt": dc, "custChrAmt": sale - dc, "supGiveAmt": round(sale * 0.85)}
rows = [line(3470403225, 1, 20260903, 16400, 820), line(3470403225, 2, 20260903, 32800, 1640, qty=2),
line(3470409999, 1, 20260904, 20000, 0, typ="RTN"), line(3470500000, 1, 20260912, 9900, 0)]
def get(url, params=None, headers=None, timeout=None):
if url.endswith("/shippingFee/period"):
return httpx.Response(200, json={"data": [{"saleAwareDt": 20260903, "prdNm": "배송비상품", "ordType": "SALE",
"ordNo": 3470403225, "ordItemNo": 3, "salePrice": 3500}],
"hasMorePage": False})
lo, hi = int(params["fromDate"]), int(params["toDate"])
return httpx.Response(200, json={"data": [r for r in rows if lo <= r["saleAwareDt"] <= hi], "hasMorePage": False})
st = FakeStore()
creds = CredentialService(st, lambda: ring())
creds.save(next(a for a in all_adapters() if a.code == "gsshop"), {"vendor_code": "1047142", "api_key": key})
orig = httpx.get
httpx.get = get
try:
r = SyncService(st, creds).sync_marketplace("gsshop", date(2026, 9, 3), date(2026, 9, 4))
finally:
httpx.get = orig
assert r["ok"], r
ev_ = {k[2]: v for k, v in st.events.items() if k[0] == "gsshop"}
assert set(ev_) == {"gs:3470403225-1-SALE-20260903", "gs:3470403225-2-SALE-20260903", "gs:3470409999-1-RTN-20260904"}
assert ev_["gs:3470403225-1-SALE-20260903"]["amount"] == 13940 and ev_["gs:3470403225-1-SALE-20260903"]["discount_amount"] == 820
assert ev_["gs:3470403225-2-SALE-20260903"]["quantity"] == 2
ret = ev_["gs:3470409999-1-RTN-20260904"]
assert ret["event_type"] == "RETURN" and ret["amount"] == -17000 and ret["sales_date"] == date(2026, 9, 4)
assert sum(v["amount"] for v in ev_.values()) == 13940 + 27880 - 17000 # 배송비 3,500 제외
httpx.get = get
try:
rec = gs.GsshopAdapter().reconcile(__import__("app.modules.performance.adapters.base", fromlist=["x"]).AdapterContext(
code="gsshop", credentials=creds.accessor("gsshop")), date(2026, 9, 3), to=date(2026, 9, 4))
finally:
httpx.get = orig
assert rec["days"][0] == {"date": "2026-09-03", "orders": 1, "amount": 41820, "claimed": 0, "ship": 3500}
assert rec["days"][1]["amount"] == -17000 and rec["days"][1]["claimed"] == 17000
def test_sync_job_cancel():
"""[업데이트 취소]: 수집 중인 쇼핑몰은 다음 API 호출 직전에 멈추고 저장하지 않는다(기존 매출 그대로),
차례가 안 온 쇼핑몰은 취소됨으로 건너뛴다. 연결 상태(오류)는 기록하지 않는다."""
import bcrypt
import httpx
from app.modules.performance import jobs
from app.modules.performance.adapters import naver as nv
job = jobs.create_job(user="king@x", start=None, end=None)
days = []
def get(url, params=None, headers=None, timeout=None):
days.append(params["from"][:10])
if len(days) == 2:
job.cancel("king@x") # 둘째 날을 받는 도중 취소
rows = [_naver_item("A" + days[-1], "P" + days[-1], days[-1], 10000)]
return httpx.Response(200, json={"data": {"contents": rows, "pagination": {"hasNext": False}}})
st = FakeStore()
st.markets = [m for m in st.markets if m["code"] in ("naver", "gsshop")]
creds = CredentialService(st, lambda: ring())
creds.save(next(a for a in all_adapters() if a.code == "naver"),
{"client_id": "app-id", "client_secret": bcrypt.gensalt(rounds=4).decode()})
creds.save(next(a for a in all_adapters() if a.code == "gsshop"),
{"vendor_code": "1047142", "api_key": "0123456789abcdef0123456789ABCDEF"})
st.events[("naver", "SALE", "naver:OLD")] = {"amount": 5000, "is_sample": False, "sales_date": date(2026, 9, 10)}
orig = (httpx.post, httpx.get, nv.CALL_INTERVAL_SEC)
httpx.post = lambda url, data=None, timeout=None, headers=None: httpx.Response(200, json={"access_token": "T", "expires_in": 10799})
httpx.get, nv.CALL_INTERVAL_SEC = get, 0
try:
res = SyncService(st, creds).sync_all(start=date(2026, 9, 9), end=date(2026, 9, 12), user="king@x", job=job)
finally:
httpx.post, httpx.get, nv.CALL_INTERVAL_SEC = orig
job.finish()
assert days == ["2026-09-09", "2026-09-10"] # 셋째 날은 부르지 않음
assert [r.get("cancelled") for r in res] == [True, True]
snap = {s["code"]: s for s in job.snapshot()["shops"]}
assert snap["naver"]["state"] == "cancelled" and snap["gsshop"]["state"] == "cancelled"
assert list(st.events) == [("naver", "SALE", "naver:OLD")] # 저장 안 함 — 기존 매출 그대로
assert "naver" not in st.status and "gsshop" not in st.status # 연결 상태 안 바뀜
snapshot = job.snapshot()
assert snapshot["cancel_requested"] and snapshot["overall"]["finished"] == 2 and snapshot["overall"]["fraction"] == 1.0
if __name__ == "__main__":
os.environ.pop("APP_ENCRYPTION_KEY", None)
n = 0
for name, fn in sorted(globals().items()):
if name.startswith("test_") and callable(fn):
fn()
n += 1
print("ok", name)
print(f"{n} tests passed")