01000757f3
- 9/6 실데이터: 매출 29,600 일치, 환불 11,900 은 정산 건별 REFUND 에 없음(다른 날 주문을 9/6 에 환불) - 후보 ① 정산 REFUND(현재 규칙) ② orders/v2 canceledAt(기간 90일 전 주문까지) ③ claims refundedDt(isRefunded) — 날짜별 합계를 나란히 + 건별(주문번호·금액·메모), 화면 숫자와 같은 후보로 규칙을 정한다 - 클레임 목록 개인정보(연락처·수거 주소·요청 사유·사진) 값·합계 숨김, 송장번호 합계도 숨김 - performance.js 캐시 버전 20261001c, 테스트·문서 갱신 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1636 lines
94 KiB
Python
1636 lines
94 KiB
Python
"""실적 모듈 테스트 — 암호화·가리기·계산·인증정보·동기화. 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 _toss_item(order_id, op_id, ordered_at, price, *, status="PAID", qty=1, dc=0, ship=0, group=None, name="밀폐용기"):
|
||
"""토스쇼핑 주문 내역 조회 results[] 한 줄(주문상품) — 개인정보 항목 포함(저장 안 되는지 확인용)."""
|
||
return {"orderId": order_id, "orderProductId": op_id, "orderedAt": ordered_at, "orderProductStatus": status,
|
||
"productName": name, "optionName": "3개입", "quantity": qty, "price": price, "originPrice": price,
|
||
"totalDiscountPrice": dc, "tossShoppingDiscount": dc, "tossPayDiscount": 0, "tossPayPoint": 0,
|
||
"deliveryFee": ship, "deliveryFeeGroupId": group,
|
||
"ordererName": "홍길동", "ordererPhone": "010-1234-5678", "receiverName": "홍길동",
|
||
"receiverPhone": "010-1234-5678", "address": "서울시 어딘가", "detailAddress": "101호", "zipCode": "01234",
|
||
"shippingNote": "문 앞에 두세요 010-9999-8888"}
|
||
|
||
|
||
class _TossCreds(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 test_toss_token_and_connection():
|
||
"""토스쇼핑: Access Key·Secret Key → OAuth2 토큰(form, scope 고정) → Bearer 로 주문 내역 조회.
|
||
HTTP 200 + resultType FAIL 도 오류, 401 이면 토큰 한 번 새로 받기. 키·토큰은 오류 문구에 없음."""
|
||
import httpx
|
||
|
||
from app.modules.performance.adapters import toss as ts
|
||
from app.modules.performance.adapters.base import AdapterContext, AdapterError
|
||
|
||
ctx = AdapterContext(code="toss", credentials=_TossCreds(api_key="ACCESS-KEY-1", api_secret="SECRET-KEY-1"))
|
||
seen = {"posts": [], "gets": []}
|
||
|
||
def post(url, data=None, timeout=None, headers=None):
|
||
seen["posts"].append((url, dict(data)))
|
||
return httpx.Response(200, json={"access_token": f"TOKEN-{len(seen['posts'])}", "expires_in": 31535999,
|
||
"token_type": "Bearer", "scope": "toss-shopping-fep:write"})
|
||
|
||
def get(url, params=None, headers=None, timeout=None):
|
||
seen["gets"].append((url, dict(params), headers["Authorization"]))
|
||
return httpx.Response(200, json={"resultType": "SUCCESS", "success": {
|
||
"results": [_toss_item(1, 11, "2026-09-30T10:00:00", 12000)], "nextCursor": "c2"}})
|
||
|
||
orig = (httpx.post, httpx.get, ts.CALL_INTERVAL_SEC)
|
||
httpx.post, httpx.get, ts.CALL_INTERVAL_SEC = post, get, 0
|
||
try:
|
||
msg = ts.TossAdapter().test_connection(ctx)
|
||
assert "연결 정상" in msg and "1건 이상" in msg
|
||
url, form = seen["posts"][0]
|
||
assert url == "https://oauth2.cert.toss.im/token"
|
||
assert form == {"grant_type": "client_credentials", "client_id": "ACCESS-KEY-1",
|
||
"client_secret": "SECRET-KEY-1", "scope": "toss-shopping-fep:write"}
|
||
gurl, params, auth = seen["gets"][0]
|
||
assert gurl == "https://shopping-fep.toss.im/api/v3/shopping-fep/orders/v2" and auth == "Bearer TOKEN-1"
|
||
assert params["startDate"] == params["endDate"] and params["limit"] == 1
|
||
assert ctx.credentials["access_token"] == "TOKEN-1" and int(ctx.credentials["access_token_expires_at"]) > 0
|
||
# 저장된 토큰은 다시 쓴다(매번 발급하지 않음) — 401 이면 한 번만 새로 받는다
|
||
n_posts = len(seen["posts"])
|
||
statuses = iter([401, 200])
|
||
httpx.get = lambda url, params=None, headers=None, timeout=None: httpx.Response(
|
||
next(statuses), json={"resultType": "SUCCESS", "success": {"results": [], "nextCursor": None}})
|
||
assert ts.TossAdapter()._window_items(ctx, date(2026, 9, 1), date(2026, 9, 1)) == []
|
||
assert len(seen["posts"]) == n_posts + 1 and ctx.credentials["access_token"] == f"TOKEN-{n_posts + 1}"
|
||
# HTTP 200 + resultType FAIL → API 오류
|
||
httpx.get = lambda url, params=None, headers=None, timeout=None: httpx.Response(
|
||
200, json={"resultType": "FAIL", "error": {"errorCode": "INVALID_DATE_RANGE", "reason": "조회 기간 초과"}})
|
||
try:
|
||
ts.TossAdapter()._window_items(ctx, date(2026, 9, 1), date(2026, 9, 1))
|
||
except AdapterError as exc:
|
||
assert exc.status == "api_error" and "INVALID_DATE_RANGE" in exc.message
|
||
else:
|
||
raise AssertionError("API 오류여야 합니다")
|
||
# 토큰 발급 거부 → 인증 실패(키는 문구에 없음)
|
||
httpx.post = lambda url, data=None, timeout=None, headers=None: httpx.Response(
|
||
401, json={"error": "invalid_client", "error_description": "client authentication failed"})
|
||
try:
|
||
ts.TossAdapter().test_connection(ctx)
|
||
except AuthFailed as exc:
|
||
assert "invalid_client" in exc.message and "SECRET-KEY-1" not in exc.message
|
||
assert "ACCESS-KEY-1" not in exc.message
|
||
else:
|
||
raise AssertionError("인증 실패여야 합니다")
|
||
# 주문 조회 403(IP 미등록 등) → 인증 실패 + IP 안내, 토큰은 문구에 없음
|
||
httpx.post = post
|
||
httpx.get = lambda url, params=None, headers=None, timeout=None: httpx.Response(
|
||
403, json={"resultType": "FAIL", "error": {"errorCode": "FORBIDDEN", "reason": "허용되지 않은 IP"}})
|
||
try:
|
||
ts.TossAdapter().test_connection(ctx)
|
||
except AuthFailed as exc:
|
||
assert "허용되지 않은 IP" in exc.message and "TOKEN-" not in exc.message
|
||
else:
|
||
raise AssertionError("권한 거부여야 합니다")
|
||
finally:
|
||
httpx.post, httpx.get, ts.CALL_INTERVAL_SEC = orig
|
||
|
||
|
||
def _toss_step(step, order_id, op_id, ts, price, *, qty=1):
|
||
"""정산 건별 목록 items[] 한 줄 — op_id None = 배송비 줄."""
|
||
return {"orderId": order_id, "orderProductId": op_id, "transactionTs": ts, "originTransactionTs": "2026-08-31T16:00:00Z",
|
||
"stepType": step, "orderProductPrice": price, "stockPrice": price // max(1, qty), "quantity": qty,
|
||
"displayProductName": "밀폐용기", "orderProductStatus": "CANCELED_PAYMENT" if step == "REFUND" else "CONFIRMED_ORDER"}
|
||
|
||
|
||
def test_toss_collect_sales():
|
||
"""토스쇼핑 매출 = 파트너스 "순 거래액" = 매출 − 환불(9/6 화면: 29,600 − 11,900 = 17,700).
|
||
매출 = 주문 단위, 주문일(한국 날짜), 주문상품 price 합(할인 전·배송비 제외, 나중에 취소·반품된 주문 포함, 결제 전 제외).
|
||
환불 = 정산 건별(거래일 기준) REFUND 상품 줄, 환불일. 31일 구간 + 커서. 구매자 정보는 저장 안 함."""
|
||
import httpx
|
||
|
||
from app.modules.performance.adapters import toss as ts
|
||
|
||
pages = {
|
||
("2026-08-01", None): ([_toss_item(1, 11, "2026-08-31T23:30:00+09:00", 20000, qty=2, dc=1000, ship=3000, group=7),
|
||
_toss_item(1, 12, "2026-08-31T23:30:00+09:00", 5000, ship=3000, group=7, name="뚜껑")], "p2"),
|
||
("2026-08-01", "p2"): ([_toss_item(2, 21, "2026-08-31T16:00:00Z", 9900, status="CANCELED_PAYMENT"), # 9/1 01:00 KST
|
||
_toss_item(3, 31, "2026-08-31T09:00:00", 4000, status="BEFORE_PAYMENT")], None),
|
||
("2026-09-01", None): ([_toss_item(4, 41, "2026-09-01T10:00:00", 15000, status="COMPLETED_RETURN")], None),
|
||
}
|
||
settle = {
|
||
("2026-08-01", None): ([_toss_step("PAY", 2, 21, "2026-08-31T16:00:00Z", 9900),
|
||
_toss_step("REFUND", 2, 21, "2026-08-31T17:30:00Z", -9900)], "s2"), # 9/1 02:30 KST
|
||
("2026-08-01", "s2"): ([_toss_step("REFUND", 2, None, "2026-08-31T17:30:00Z", -3000), # 배송비 줄 → 제외
|
||
_toss_step("REFUND", 9, 91, "2026-07-31T10:00:00", -5000)], None), # 기간 밖
|
||
("2026-09-01", None): ([_toss_step("REFUND", 4, 41, "2026-09-02T09:00:00+09:00", 15000)], None),
|
||
}
|
||
calls, scalls = [], []
|
||
|
||
def get(url, params=None, headers=None, timeout=None):
|
||
if url.endswith("/settlement-steps"):
|
||
assert params["dateCondition"] == "TRANSACTION_DATE" and params["size"] == 100
|
||
scalls.append((params["fromDate"], params["toDate"], params.get("nextToken")))
|
||
rows, tok = settle.get((params["fromDate"], params.get("nextToken")), ([], None))
|
||
return httpx.Response(200, json={"resultType": "SUCCESS", "success": {"items": rows, "nextToken": tok}})
|
||
key = (params["startDate"], params.get("nextCursor"))
|
||
calls.append((params["startDate"], params["endDate"], params.get("nextCursor")))
|
||
rows, cur = pages.get(key, ([], None))
|
||
return httpx.Response(200, json={"resultType": "SUCCESS", "success": {"results": rows, "nextCursor": cur}})
|
||
|
||
def post(url, data=None, timeout=None, headers=None):
|
||
return httpx.Response(200, json={"access_token": "TOKEN-T", "expires_in": 31535999})
|
||
|
||
st = FakeStore()
|
||
creds = CredentialService(st, lambda: ring())
|
||
creds.save(next(a for a in all_adapters() if a.code == "toss"), {"api_key": "ak", "api_secret": "sk"})
|
||
orig = (httpx.post, httpx.get, ts.CALL_INTERVAL_SEC)
|
||
httpx.post, httpx.get, ts.CALL_INTERVAL_SEC = post, get, 0
|
||
try:
|
||
r = SyncService(st, creds).sync_marketplace("toss", date(2026, 8, 1), date(2026, 9, 2))
|
||
finally:
|
||
httpx.post, httpx.get, ts.CALL_INTERVAL_SEC = orig
|
||
assert r["ok"], r
|
||
assert calls == [("2026-08-01", "2026-08-31", None), ("2026-08-01", "2026-08-31", "p2"),
|
||
("2026-09-01", "2026-09-02", None)] # 31일 구간 + 커서
|
||
assert scalls == [("2026-08-01", "2026-08-31", None), ("2026-08-01", "2026-08-31", "s2"),
|
||
("2026-09-01", "2026-09-02", None)]
|
||
ev_ = {k[2]: v for k, v in st.events.items() if k[0] == "toss"}
|
||
refunds = {k: v for k, v in ev_.items() if k.startswith("toss:R")}
|
||
assert set(ev_) - set(refunds) == {"toss:1", "toss:2", "toss:4"} # 결제 전(3)만 제외
|
||
assert sorted((v["amount"], v["sales_date"]) for v in refunds.values()) == [
|
||
(-15000, date(2026, 9, 2)), (-9900, date(2026, 9, 1))] # 환불일 기준, 배송비 줄·기간 밖 제외
|
||
assert all(v["event_type"] == "CANCEL" for v in refunds.values())
|
||
# 순 거래액: 9/1 = 매출 9,900(주문 2) − 환불 9,900 = 0, 9/2 = 0 − 15,000
|
||
net = {}
|
||
for v in ev_.values():
|
||
net[v["sales_date"]] = net.get(v["sales_date"], 0) + v["amount"]
|
||
assert net == {date(2026, 8, 31): 25000, date(2026, 9, 1): 15000 + 9900 - 9900, date(2026, 9, 2): -15000}
|
||
assert ev_["toss:1"]["amount"] == 25000 and ev_["toss:1"]["discount_amount"] == 1000 # 할인 전·배송비 제외
|
||
assert ev_["toss:1"]["quantity"] == 3 and ev_["toss:1"]["product_name"] == "밀폐용기 외 1건"
|
||
assert ev_["toss:1"]["sales_date"] == date(2026, 8, 31)
|
||
assert ev_["toss:2"]["amount"] == 9900 and ev_["toss:2"]["sales_date"] == date(2026, 9, 1) # UTC → 한국 날짜
|
||
assert ev_["toss:4"]["amount"] == 15000 and ev_["toss:4"]["order_status"] == "반품완료"
|
||
assert "홍길동" not in repr(st.events) and "010-1234-5678" not in repr(st.events)
|
||
|
||
|
||
def test_toss_reconcile_hides_personal():
|
||
import time as _t
|
||
|
||
import httpx
|
||
|
||
from app.modules.performance.adapters import toss as ts
|
||
from app.modules.performance.adapters.base import AdapterContext
|
||
|
||
ctx = AdapterContext(code="toss", credentials=_TossCreds(api_key="a", api_secret="b", access_token="T",
|
||
access_token_expires_at=str(int(_t.time()) + 99999)))
|
||
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)]
|
||
|
||
# 다른 날(8/20) 주문을 9/10 에 취소 — 기간 앞(90일) 주문 조회에서만 보인다
|
||
old = {**_toss_item(7, 71, "2026-08-20T10:00:00", 11900, status="CANCELED_PAYMENT"), "canceledAt": "2026-09-10T09:00:00"}
|
||
claims = [{"id": 1, "type": "RETURN", "status": "COMPLETED", "isRefunded": True, "refundedDt": "2026-09-10T12:00:00",
|
||
"requestReason": "단순 변심 010-5555-6666", "returnAddress": "서울시 반품동",
|
||
"order": {"id": 8, "orderProductId": 81, "price": 5000, "createdDt": "2026-08-25T10:00:00",
|
||
"ordererName": "홍길동", "ordererPhoneNumber": "010-1234-5678"},
|
||
"product": {"id": 3, "name": "밀폐용기", "quantity": 1}},
|
||
{"id": 2, "type": "CANCEL", "status": "REQUESTED", "isRefunded": False, "order": {"id": 9, "price": 777}}]
|
||
|
||
def get(url, params=None, headers=None, timeout=None):
|
||
if url.endswith("/settlement-steps"):
|
||
return httpx.Response(200, json={"resultType": "SUCCESS", "success": {"items": steps, "nextToken": None}})
|
||
if url.endswith("/claims"):
|
||
return httpx.Response(200, json={"resultType": "SUCCESS", "success": {"items": claims, "nextToken": None,
|
||
"hasNext": False}})
|
||
found = rows if params["startDate"] >= "2026-09-09" else [old] if params["startDate"] <= "2026-08-20" <= params["endDate"] else []
|
||
return httpx.Response(200, json={"resultType": "SUCCESS", "success": {"results": found, "nextCursor": None}})
|
||
|
||
orig = (httpx.get, ts.CALL_INTERVAL_SEC)
|
||
httpx.get, ts.CALL_INTERVAL_SEC = get, 0
|
||
try:
|
||
rec = ts.TossAdapter().reconcile(ctx, date(2026, 9, 9), to=date(2026, 9, 10))
|
||
finally:
|
||
httpx.get, ts.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["price"]["sum"] == 29900
|
||
for k in ("ordererName", "ordererPhone", "address", "zipCode", "shippingNote"):
|
||
assert f[k]["personal"] and f[k]["sample"] == "", k
|
||
assert not f["productName"]["personal"] and f["productName"]["sample"] == "밀폐용기"
|
||
assert "홍길동" not in repr(rec) and "010-1234-5678" not in repr(rec) and "010-9999-8888" not in repr(rec)
|
||
# 날짜별: 매출(주문일) · 환불(환불일, 배송비 줄 제외) · 순 거래액
|
||
assert rec["days"] == [{"date": "2026-09-09", "orders": 2, "amount": 29900, "claimed": 0, "ship": 29900},
|
||
{"date": "2026-09-10", "orders": 0, "amount": 0, "claimed": 9900, "ship": -9900}]
|
||
assert rec["day_cols"]["ship"].startswith("순 거래액")
|
||
labels = [p["label"] for p in rec["probes"]]
|
||
assert any("결제 뒤 취소·반품(매출 포함)" in x for x in labels)
|
||
assert any(x.startswith("정산 REFUND — 환불") for x in labels) and any("배송비 줄" in x for x in labels)
|
||
# 환불 후보 세 가지 — 날짜별 합계 + 건별
|
||
cand = {c["key"]: c for c in rec["refund_candidates"]}
|
||
assert cand["settlement"]["days"] == {"2026-09-10": 9900}
|
||
assert cand["canceled"]["days"] == {"2026-09-10": 11900} and cand["canceled"]["rows"][0]["orderId"] == "7"
|
||
assert "주문일 2026-08-20" in cand["canceled"]["rows"][0]["note"]
|
||
assert cand["claims"]["days"] == {"2026-09-10": 5000} and len(cand["claims"]["rows"]) == 1 # 환불 안 된 클레임 제외
|
||
cf = {x["name"]: x for x in next(p for p in rec["probes"] if p["key"] == "claims")["fields"]}
|
||
assert cf["requestReason"]["personal"] and cf["returnAddress"]["personal"] and cf["order.ordererPhoneNumber"]["personal"]
|
||
assert "010-5555-6666" not in repr(rec) and "반품동" not in repr(rec)
|
||
|
||
|
||
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")
|