Files
dbx-main/app/modules/performance/tests/test_performance.py
T
king dd6a849fbd feat(performance): 쿠팡 연결 테스트 — HMAC(CEA) 서명으로 발주서 실제 조회
쿠팡 OPEN API 키를 입력했지만 연결 테스트가 "다음 단계에서 구현"만 돌려줘
키가 이 서버에서 통하는지 알 수 없었다. 키는 판매자당 1개이고 사방넷용
(연동업체 선택)으로 발급한 키는 이 서버 IP 에서 막힐 수 있어 먼저 확인이 필요.

- CEA HMAC-SHA256 서명(signed-date + METHOD + path + query, 공식 예제 방식),
  쿠팡 예시와 같은 쿼리 인코딩(+ → %2B, : 유지)
- test_connection: 오늘 결제완료 발주서(v5 ordersheets) 1건 조회
- 401/403 → 인증 실패 + "연동업체 키면 자체개발로 바꾸고 이 서버 IP 허용" 안내
- 매출 수집은 아직 — 맞출 WING 화면을 정한 뒤 구현(주석에 API 조사 결과)
- 테스트: 서명 형식·쿼리 인코딩·403 메시지·비밀값 미노출

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

832 lines
47 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 (
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)
r = svc.sync_marketplace("elevenst", date(2026, 9, 29), date(2026, 9, 29))
assert r["status"] == "not_configured" # 키 미입력
creds.save(next(a for a in all_adapters() if a.code == "elevenst"), {"api_key": "k-123456"})
r = svc.sync_marketplace("elevenst", date(2026, 9, 29), date(2026, 9, 29))
assert r["status"] == "not_implemented" and "k-123456" not in r["message"]
t = svc.test_connection("elevenst", values={"api_key": "typed-only"})
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_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}")
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")