"""실적 모듈 테스트 — 암호화·가리기·계산·인증정보·동기화. 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"")) 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 = ('12' '').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 = '-1허용되지 않은 IP' for status, body, kind in ((200, err.encode(), ApiError), (403, b"Forbidden", AuthFailed), (200, b"IP not allowed", 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 = ("" + "".join( f"{n}{a}홍길동상품{n}" f"2026-09-29 10:00:00" for n, a in ((1, 10000), (2, 5500))) + "").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"not found") if "/ordservices/" in url: return httpx.Response(200, content=b"") if "/claimservice/" in url: return httpx.Response(200, content="-1" "해당 건이 없습니다.".encode()) return httpx.Response(404, content=b"not found") 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"{no}{seq}{day} 15:13:16" f"{amt}{pay}{ship}{qty}" f"밀폐용기홍길동18550503") def stl(no, pay_day, amt, qty, cupn=0): return (f"{no}1홍길동" f"{pay_day}2026/09/19밀폐용기{qty}" f"{amt}{amt - 100}{cupn}") settlement = ("" + 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) + "").encode() completed = ("" + 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) + "").encode() packaging = ("" + 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) + "").encode() empty = "-1해당 건이 없습니다.".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")