chore(cafe24): 정리 전 완료된 작업 보존
Cafe24 수정, 테스트 및 DB 마이그레이션 파일을 함께 기록한다.
This commit is contained in:
@@ -8,6 +8,7 @@ DB/네트워크 없이 검증한다(가짜 저장소 + refresh 함수 주입).
|
||||
from __future__ import annotations
|
||||
|
||||
import ftplib
|
||||
import logging
|
||||
import os
|
||||
from contextlib import contextmanager
|
||||
from datetime import timedelta
|
||||
@@ -15,7 +16,8 @@ from datetime import timedelta
|
||||
from app.integrations.cafe24 import config as cfgmod
|
||||
from app.integrations.cafe24 import crypto, oauth, products, tokens
|
||||
from app.integrations.cafe24.errors import Cafe24ApiError, Cafe24AuthError, Cafe24ConfigError
|
||||
from app.modules.cafe24 import store, worker
|
||||
from app.modules.cafe24 import store, worker, writes
|
||||
from app.modules.cafe24.tests import fakes
|
||||
from app.timezone import now_kst
|
||||
|
||||
SECRET = "unit-test-secret"
|
||||
@@ -25,6 +27,8 @@ SECRET = "unit-test-secret"
|
||||
# 값을 돌려줌) 재시도 예산을 다 채우게 되는데, 테스트에서까지 그 시간을 그대로
|
||||
# 기다릴 필요는 없다.
|
||||
products.time.sleep = lambda *_a, **_k: None
|
||||
# 장애 주입 테스트가 남기는 logger.exception 출력은 결과와 무관하다 — 조용히.
|
||||
logging.getLogger("cafe24").setLevel(logging.CRITICAL)
|
||||
|
||||
_TEST_ENV = {
|
||||
"CAFE24_MALL_ID": "testmall",
|
||||
@@ -711,203 +715,303 @@ def test_design_file_path_env_override():
|
||||
os.environ["CAFE24_PC_DETAIL_FTP_PATH"] = saved
|
||||
|
||||
|
||||
class _FakeFTP:
|
||||
"""ftplib.FTP 대역 — 실제 소켓 없이 RETR/STOR 명령만 흉내낸다."""
|
||||
|
||||
files: dict[str, bytes] = {}
|
||||
|
||||
def __init__(self):
|
||||
self.calls = []
|
||||
|
||||
def connect(self, host, port, timeout=None):
|
||||
self.calls.append(("connect", host, port))
|
||||
|
||||
def login(self, user, password):
|
||||
self.calls.append(("login", user, password))
|
||||
|
||||
def set_pasv(self, value):
|
||||
pass
|
||||
|
||||
def retrbinary(self, cmd, callback):
|
||||
path = cmd.split(" ", 1)[1]
|
||||
if path not in self.files:
|
||||
raise ftplib.error_perm("550 No such file")
|
||||
callback(self.files[path])
|
||||
|
||||
def storbinary(self, cmd, fp):
|
||||
path = cmd.split(" ", 1)[1]
|
||||
self.files[path] = fp.read()
|
||||
|
||||
def quit(self):
|
||||
self.calls.append(("quit",))
|
||||
_FTP_CFG = cfgmod.Cafe24FtpConfig(host="h", port=21, user="u", password="p")
|
||||
_SWIPER = "/sde_design/mobile11/product-swiper/product-swiper.js"
|
||||
|
||||
|
||||
def test_design_ftp_read_and_write_roundtrip():
|
||||
from app.integrations.cafe24 import design_ftp
|
||||
|
||||
path = "/sde_design/mobile11/product-swiper/product-swiper.js"
|
||||
_FakeFTP.files = {path: "old".encode("utf-8")}
|
||||
saved = ftplib.FTP
|
||||
ftplib.FTP = _FakeFTP
|
||||
try:
|
||||
cfg = cfgmod.Cafe24FtpConfig(host="h", port=21, user="u", password="p")
|
||||
content = design_ftp.read_text_file(cfg, path)
|
||||
assert content == "old"
|
||||
|
||||
design_ftp.write_text_file(cfg, path, "new content")
|
||||
assert design_ftp.read_text_file(cfg, path) == "new content"
|
||||
finally:
|
||||
ftplib.FTP = saved
|
||||
with fakes.patched_ftp() as ftp:
|
||||
ftp.reset({_SWIPER: "old".encode("utf-8")})
|
||||
assert design_ftp.read_text_file(_FTP_CFG, _SWIPER) == "old"
|
||||
design_ftp.write_text_file(_FTP_CFG, _SWIPER, "new content", expected_current="old")
|
||||
assert design_ftp.read_text_file(_FTP_CFG, _SWIPER) == "new content"
|
||||
# 원본에 직접 STOR 하지 않는다 — 임시 파일에 올린 뒤 이름 바꾸기로 교체
|
||||
stors = [e for e in ftp.log if e[0] == "STOR"]
|
||||
assert stors and all(".cf24tmp-" in e[1] for e in stors), ftp.log
|
||||
assert any(e[0] == "RENAME" and e[2] == _SWIPER for e in ftp.log)
|
||||
# 임시 파일이 남지 않는다
|
||||
assert set(ftp.files) == {_SWIPER}
|
||||
|
||||
|
||||
def test_design_ftp_missing_file_raises_cafe24_error():
|
||||
from app.integrations.cafe24 import design_ftp
|
||||
from app.integrations.cafe24.errors import Cafe24FtpError
|
||||
|
||||
_FakeFTP.files = {}
|
||||
saved = ftplib.FTP
|
||||
ftplib.FTP = _FakeFTP
|
||||
try:
|
||||
cfg = cfgmod.Cafe24FtpConfig(host="h", port=21, user="u", password="p")
|
||||
with fakes.patched_ftp() as ftp:
|
||||
ftp.reset({})
|
||||
try:
|
||||
design_ftp.read_text_file(cfg, "/missing.js")
|
||||
design_ftp.read_text_file(_FTP_CFG, "/missing.js")
|
||||
raise AssertionError("Cafe24FtpError 가 났어야 한다")
|
||||
except Cafe24FtpError:
|
||||
pass
|
||||
finally:
|
||||
ftplib.FTP = saved
|
||||
|
||||
|
||||
def test_design_ftp_truncated_upload_keeps_original():
|
||||
"""[04] 전송이 잘려도 원본은 그대로 — 임시 파일 검증에서 멈춘다."""
|
||||
from app.integrations.cafe24 import design_ftp
|
||||
from app.integrations.cafe24.errors import Cafe24FtpError
|
||||
|
||||
with fakes.patched_ftp() as ftp:
|
||||
ftp.reset({_SWIPER: b"ORIGINAL"})
|
||||
ftp.truncate_store = True
|
||||
try:
|
||||
design_ftp.write_text_file(_FTP_CFG, _SWIPER, "NEW CONTENT 1234", expected_current="ORIGINAL")
|
||||
raise AssertionError("잘린 업로드를 성공으로 처리했다")
|
||||
except Cafe24FtpError as exc:
|
||||
assert exc.maybe_applied is False
|
||||
assert ftp.files == {_SWIPER: b"ORIGINAL"} # 원본 그대로 + 임시 파일 정리
|
||||
|
||||
|
||||
def test_design_ftp_rename_unsupported_aborts_without_direct_stor():
|
||||
"""[04] 이름 바꾸기를 지원하지 않으면 중단 — 원본에 직접 쓰지 않는다."""
|
||||
from app.integrations.cafe24 import design_ftp
|
||||
from app.integrations.cafe24.errors import Cafe24FtpError
|
||||
|
||||
with fakes.patched_ftp() as ftp:
|
||||
ftp.reset({_SWIPER: b"ORIGINAL"})
|
||||
ftp.rename_mode = "unsupported"
|
||||
try:
|
||||
design_ftp.write_text_file(_FTP_CFG, _SWIPER, "NEW", expected_current="ORIGINAL")
|
||||
raise AssertionError("rename 미지원인데 진행했다")
|
||||
except Cafe24FtpError as exc:
|
||||
assert "rename" in str(exc)
|
||||
assert ftp.files == {_SWIPER: b"ORIGINAL"}
|
||||
assert not any(e == ("STOR", _SWIPER) for e in ftp.log)
|
||||
|
||||
|
||||
def test_design_ftp_no_overwrite_rename_swaps_safely():
|
||||
"""덮어쓰기 rename 을 거부하는 서버 — 원본을 비킨 뒤 교체하고 비킨 파일은 지운다."""
|
||||
from app.integrations.cafe24 import design_ftp
|
||||
|
||||
with fakes.patched_ftp() as ftp:
|
||||
ftp.reset({_SWIPER: b"ORIGINAL"})
|
||||
ftp.rename_mode = "no_overwrite"
|
||||
design_ftp.write_text_file(_FTP_CFG, _SWIPER, "NEW", expected_current="ORIGINAL")
|
||||
assert ftp.files == {_SWIPER: b"NEW"}
|
||||
|
||||
|
||||
def test_design_ftp_conflict_right_before_replace():
|
||||
"""[04] 교체 직전 원본이 바뀌어 있으면(남이 수정) 덮지 않고 멈춘다."""
|
||||
from app.integrations.cafe24 import design_ftp
|
||||
from app.integrations.cafe24.errors import Cafe24FtpConflict
|
||||
|
||||
with fakes.patched_ftp() as ftp:
|
||||
ftp.reset({_SWIPER: b"SOMEONE ELSE"})
|
||||
try:
|
||||
design_ftp.write_text_file(_FTP_CFG, _SWIPER, "MINE", expected_current="ORIGINAL")
|
||||
raise AssertionError("충돌을 못 잡았다")
|
||||
except Cafe24FtpConflict:
|
||||
pass
|
||||
assert ftp.files == {_SWIPER: b"SOMEONE ELSE"}
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════
|
||||
# 예약 worker — 성공/재시도/최종실패
|
||||
# 예약 worker — 성공/재시도/최종실패/확인 필요/중단 복구 (메모리 저장소 대역)
|
||||
# 실제 DB 의 lease·SKIP LOCKED 는 test_cafe24_db.py 에서 검증한다.
|
||||
# ════════════════════════════════════════════════════════════
|
||||
class _FakeStore:
|
||||
"""worker 가 쓰는 저장소 메서드만 흉내낸다."""
|
||||
|
||||
def __init__(self, rows):
|
||||
self.rows = list(rows)
|
||||
self.revisions = {}
|
||||
self.added = []
|
||||
self.finished = []
|
||||
self.audits = []
|
||||
|
||||
@contextmanager
|
||||
def claim_due_schedule(self, *, now):
|
||||
yield self.rows.pop(0) if self.rows else None
|
||||
|
||||
def get_revision(self, revision_id):
|
||||
return self.revisions.get(int(revision_id), {})
|
||||
|
||||
def add_revision(self, **fields):
|
||||
self.added.append(fields)
|
||||
return 900 + len(self.added)
|
||||
|
||||
def save_write_snapshot(self, product_no, section, data):
|
||||
self.snapshots = getattr(self, "snapshots", [])
|
||||
self.snapshots.append((product_no, section, data))
|
||||
|
||||
def finish_schedule(self, schedule_id, *, status, error="", next_retry_at=None, retry_count=None):
|
||||
self.finished.append(
|
||||
{"id": schedule_id, "status": status, "error": error,
|
||||
"next_retry_at": next_retry_at, "retry_count": retry_count}
|
||||
)
|
||||
|
||||
def log_audit(self, **fields):
|
||||
self.audits.append(fields)
|
||||
|
||||
|
||||
class _FakeApi:
|
||||
def __init__(self, client):
|
||||
self.client = client
|
||||
|
||||
|
||||
class _WorkerClient(_FakeClient):
|
||||
"""PUT 을 실패시킬 수 있는 클라이언트."""
|
||||
|
||||
def __init__(self, payload=None, fail_put=None):
|
||||
super().__init__(payload)
|
||||
self.fail_put = fail_put
|
||||
|
||||
def put(self, path, *, params=None, json=None, product_no=None):
|
||||
if self.fail_put:
|
||||
raise self.fail_put
|
||||
return super().put(path, params=params, json=json, product_no=product_no)
|
||||
|
||||
|
||||
def _schedule_row(**overrides):
|
||||
row = {
|
||||
"id": 7, "product_no": 131, "revision_id": 55,
|
||||
"set_display": True, "set_selling": None, "retry_count": 0,
|
||||
}
|
||||
row.update(overrides)
|
||||
return row
|
||||
def _worker_env(description="<p>A</p>", **schedule):
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24(description)
|
||||
api = fakes.FakeApi(cafe)
|
||||
rid = st.add_revision(product_no=131, html_content="<p>예약 내용</p>", revision_type="DRAFT")
|
||||
fields = {"revision_id": rid, "set_display": True}
|
||||
fields.update(schedule)
|
||||
sid = st.add_schedule(**fields)
|
||||
return st, cafe, api, sid, rid
|
||||
|
||||
|
||||
def test_worker_applies_html_and_flags():
|
||||
st = _FakeStore([_schedule_row()])
|
||||
st.revisions[55] = {"html_content": "<p>예약 내용</p>"}
|
||||
client = _WorkerClient({"product": _PRODUCT})
|
||||
assert worker.process_once(st, _FakeApi(client)) == 1
|
||||
st, cafe, api, sid, _rid = _worker_env()
|
||||
assert worker.process_once(st, api) == 1
|
||||
|
||||
# 쓰기 직전 현재값을 읽어 BACKUP 을 남겼는가
|
||||
assert any(r["revision_type"] == store.REVISION_BACKUP for r in st.added)
|
||||
backups = st.of_type(store.REVISION_BACKUP)
|
||||
assert backups and backups[0]["html_content"] == "<p>A</p>"
|
||||
assert backups[0]["source"] == store.SOURCE_OBSERVED
|
||||
# HTML 과 진열 상태를 한 번의 PUT 으로 보냈는가
|
||||
put = [c for c in client.calls if c["method"] == "PUT"][0]
|
||||
assert put["json"]["request"]["description"] == "<p>예약 내용</p>"
|
||||
put = cafe.puts()[0]
|
||||
assert put[2]["request"]["description"] == "<p>예약 내용</p>"
|
||||
# mobile_description 은 보내지 않는다 — separated_mobile_description="F" 로
|
||||
# "PC 상세설명과 동일"을 강제한다(직접 보내면 "직접 등록"으로 바뀌어버린다).
|
||||
assert "mobile_description" not in put["json"]["request"]
|
||||
assert put["json"]["request"]["separated_mobile_description"] == "F"
|
||||
assert put["json"]["request"]["display"] == "T"
|
||||
assert "selling" not in put["json"]["request"] # 변경 없음이면 보내지 않는다
|
||||
assert st.finished == [
|
||||
{"id": 7, "status": store.STATUS_SUCCESS, "error": "",
|
||||
"next_retry_at": None, "retry_count": None}
|
||||
]
|
||||
assert "mobile_description" not in put[2]["request"]
|
||||
assert put[2]["request"]["separated_mobile_description"] == "F"
|
||||
assert put[2]["request"]["display"] == "T"
|
||||
assert "selling" not in put[2]["request"] # 변경 없음이면 보내지 않는다
|
||||
row = st.schedules[sid]
|
||||
assert row["status"] == store.STATUS_SUCCESS and row["last_error"] == ""
|
||||
assert row["lease_token"] == "" # 끝나면 lease 를 비운다
|
||||
assert len(st.of_type(store.REVISION_SCHEDULED)) == 1
|
||||
assert list(st.attempts.values())[0]["status"] == store.ATTEMPT_RECORDED
|
||||
assert st.locks == {} # 상품 잠금 해제
|
||||
|
||||
|
||||
def test_worker_flags_only_skips_backup():
|
||||
"""HTML 없이 진열/판매만 바꾸는 예약은 상세설명을 읽거나 백업하지 않는다."""
|
||||
st = _FakeStore([_schedule_row(revision_id=None, set_selling=False)])
|
||||
client = _WorkerClient({"product": _PRODUCT})
|
||||
assert worker.process_once(st, _FakeApi(client)) == 1
|
||||
assert st.added == [] # 백업 없음
|
||||
put = [c for c in client.calls if c["method"] == "PUT"][0]
|
||||
assert "description" not in put["json"]["request"]
|
||||
assert put["json"]["request"] == {"display": "T", "selling": "F"}
|
||||
st, cafe, api, sid, _ = _worker_env(revision_id=None, set_selling=False)
|
||||
before = len(st.revisions)
|
||||
assert worker.process_once(st, api) == 1
|
||||
assert len(st.revisions) == before # 백업·SCHEDULED 버전 없음
|
||||
put = cafe.puts()[0]
|
||||
assert put[2]["request"] == {"display": "T", "selling": "F"}
|
||||
assert st.schedules[sid]["status"] == store.STATUS_SUCCESS
|
||||
|
||||
|
||||
def test_worker_retries_then_fails():
|
||||
"""실패는 재시도 예산 안에서 다시 시도하고, 소진되면 FAILED 로 확정한다."""
|
||||
boom = Cafe24ApiError("서버 오류", status=500)
|
||||
|
||||
st = _FakeStore([_schedule_row(retry_count=0)])
|
||||
st.revisions[55] = {"html_content": "<p>x</p>"}
|
||||
worker.process_once(st, _FakeApi(_WorkerClient({"product": _PRODUCT}, fail_put=boom)))
|
||||
first = st.finished[0]
|
||||
"""거절(반영 안 됨이 확실)은 재시도 예산 안에서 다시 시도하고, 소진되면 FAILED."""
|
||||
st, cafe, api, sid, _ = _worker_env()
|
||||
cafe.put_error = Cafe24ApiError("잘못된 요청", status=422)
|
||||
worker.process_once(st, api)
|
||||
first = st.schedules[sid]
|
||||
assert first["status"] == store.STATUS_PENDING # 다시 대기로
|
||||
assert first["retry_count"] == 1
|
||||
assert first["next_retry_at"] is not None
|
||||
assert list(st.attempts.values())[-1]["status"] == store.ATTEMPT_REMOTE_FAILED
|
||||
|
||||
st2 = _FakeStore([_schedule_row(retry_count=store.MAX_RETRY)])
|
||||
st2.revisions[55] = {"html_content": "<p>x</p>"}
|
||||
worker.process_once(st2, _FakeApi(_WorkerClient({"product": _PRODUCT}, fail_put=boom)))
|
||||
assert st2.finished[0]["status"] == store.STATUS_FAILED
|
||||
st2, cafe2, api2, sid2, _ = _worker_env(retry_count=store.MAX_RETRY)
|
||||
cafe2.put_error = Cafe24ApiError("서버 오류", status=400)
|
||||
worker.process_once(st2, api2)
|
||||
assert st2.schedules[sid2]["status"] == store.STATUS_FAILED
|
||||
assert any(a["result"] == "FAIL" for a in st2.audits)
|
||||
|
||||
|
||||
def test_worker_missing_revision_is_failure_not_crash():
|
||||
st = _FakeStore([_schedule_row(revision_id=999, retry_count=store.MAX_RETRY)])
|
||||
worker.process_once(st, _FakeApi(_WorkerClient({"product": _PRODUCT})))
|
||||
assert st.finished[0]["status"] == store.STATUS_FAILED
|
||||
assert "999" in st.finished[0]["error"]
|
||||
st, _cafe, api, sid, _ = _worker_env(revision_id=999, retry_count=store.MAX_RETRY)
|
||||
worker.process_once(st, api)
|
||||
assert st.schedules[sid]["status"] == store.STATUS_FAILED
|
||||
assert "999" in st.schedules[sid]["last_error"]
|
||||
|
||||
|
||||
def test_worker_stops_when_nothing_due():
|
||||
st = _FakeStore([])
|
||||
assert worker.process_once(st, _FakeApi(_WorkerClient())) == 0
|
||||
st = fakes.MemoryStore()
|
||||
assert worker.process_once(st, fakes.FakeApi(fakes.FakeCafe24())) == 0
|
||||
|
||||
|
||||
def test_worker_unknown_result_needs_review_not_retry():
|
||||
"""[05][07] 응답 유실(반영 여부 모름) — 재시도로 한 번 더 쓰지 않고 확인 필요로 둔다."""
|
||||
st, cafe, api, sid, _ = _worker_env()
|
||||
cafe.put_error = fakes.network_error(maybe_applied=True)
|
||||
cafe.put_error_after_apply = True
|
||||
worker.process_once(st, api)
|
||||
assert st.schedules[sid]["status"] == store.STATUS_NEEDS_REVIEW
|
||||
assert list(st.attempts.values())[-1]["status"] == store.ATTEMPT_UNKNOWN
|
||||
worker.process_once(st, api)
|
||||
assert len(cafe.puts()) == 1 # 다시 쓰지 않았다
|
||||
|
||||
|
||||
def test_worker_remote_ok_but_record_failure_is_success_not_failed():
|
||||
"""[07] PUT 성공 뒤 로컬 버전 기록 실패 → FAILED 가 아니라 SUCCESS + 기록 복구 메모, 재적용 없음."""
|
||||
st, cafe, api, sid, _ = _worker_env()
|
||||
st.fail_on.add("record_attempt_revision")
|
||||
worker.process_once(st, api)
|
||||
row = st.schedules[sid]
|
||||
assert row["status"] == store.STATUS_SUCCESS, row
|
||||
assert "기록" in row["last_error"]
|
||||
attempt = list(st.attempts.values())[-1]
|
||||
assert attempt["status"] == store.ATTEMPT_REMOTE_OK # 반영됨, 기록 복구 대기
|
||||
# 다음 주기: 기록 복구만 하고 다시 PUT 하지 않는다
|
||||
st.fail_on.clear()
|
||||
worker.process_once(st, api)
|
||||
assert len(cafe.puts()) == 1
|
||||
assert attempt["status"] == store.ATTEMPT_RECORDED
|
||||
assert len(st.of_type(store.REVISION_SCHEDULED)) == 1
|
||||
|
||||
|
||||
def test_worker_busy_product_defers_without_burning_retry():
|
||||
"""[02] 같은 상품을 다른 작업이 쓰는 중이면 쓰지 않고 잠시 뒤로 미룬다(재시도 횟수 그대로)."""
|
||||
st, cafe, api, sid, _ = _worker_env()
|
||||
st.acquire_lock("product:131", owner="king|web:1", purpose="상세설명 적용", ttl_seconds=60)
|
||||
worker.process_once(st, api)
|
||||
row = st.schedules[sid]
|
||||
assert row["status"] == store.STATUS_PENDING and row["retry_count"] == 0
|
||||
assert row["next_retry_at"] is not None
|
||||
assert cafe.puts() == []
|
||||
|
||||
|
||||
def test_worker_backup_uses_confirmed_last_write_during_lag():
|
||||
"""[06] 예약 직전 카페24가 읽기 지연으로 옛 HTML 을 돌려줘도, 백업은 마지막 확인된 적용값."""
|
||||
st, cafe, api, sid, _ = _worker_env(description="<p>OLD</p>")
|
||||
# 방금 웹에서 NEW 를 적용(확인된 쓰기) — 카페24 GET 은 아직 OLD
|
||||
with writes.write_lock(st, "product:131", actor="king", purpose="t") as lock:
|
||||
writes.write_product(st, api, 131, lock=lock, origin=store.ORIGIN_MANUAL, actor="king",
|
||||
html="<p>NEW</p>", wait_confirm=False)
|
||||
cafe.stale = {**cafe.state, "description": "<p>OLD</p>", "mobile_description": "<p>OLD</p>",
|
||||
"updated_date": "2026-09-30T09:00:00+09:00"}
|
||||
worker.process_once(st, api)
|
||||
backups = [r for r in st.of_type(store.REVISION_BACKUP) if "예약" in r["memo"]]
|
||||
assert backups and backups[-1]["html_content"] == "<p>NEW</p>", backups
|
||||
assert backups[-1]["source"] == store.SOURCE_LAST_WRITE
|
||||
|
||||
|
||||
def test_worker_recovers_expired_processing_by_attempt_state():
|
||||
"""[05] lease 만료 PROCESSING — 시도 기록으로 판정(무조건 PENDING 금지)."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
api = fakes.FakeApi(cafe)
|
||||
rid = st.add_revision(product_no=131, html_content="<p>예약</p>", revision_type="DRAFT")
|
||||
|
||||
def processing(**fields):
|
||||
sid = st.add_schedule(revision_id=rid, status=store.STATUS_PROCESSING,
|
||||
lease_token="dead", started_at=now_kst(), **fields)
|
||||
st.expire_schedule_lease(sid)
|
||||
return sid
|
||||
|
||||
# (1) 원격 쓰기 전에 죽음 → 재시도 대기
|
||||
s1 = processing()
|
||||
# (2) 반영·기록까지 끝난 뒤 죽음 → 완료
|
||||
s2 = processing()
|
||||
st.start_attempt(product_no=131, schedule_id=s2, origin="SCHEDULED", target_digest="x",
|
||||
target_revision_id=rid)
|
||||
st.attempts[max(st.attempts)]["status"] = store.ATTEMPT_RECORDED
|
||||
# (3) 반영됐고 기록 전에 죽음 → 기록 채우고 완료(재적용 없음)
|
||||
s3 = processing()
|
||||
a3 = st.start_attempt(product_no=131, schedule_id=s3, origin="SCHEDULED",
|
||||
target_digest=store.content_digest("<p>예약</p>"), target_revision_id=rid)
|
||||
st.attempts[a3]["status"] = store.ATTEMPT_REMOTE_OK
|
||||
# (4) PUT 도중 죽음, 카페24 값은 예약 결과와 다름 → 확인 필요
|
||||
s4 = processing()
|
||||
st.start_attempt(product_no=131, schedule_id=s4, origin="SCHEDULED",
|
||||
target_digest=store.content_digest("<p>예약</p>"), target_revision_id=rid)
|
||||
# (5) 레거시(lease 없음) PROCESSING, 40분 전 → 만료로 보고 재시도 대기
|
||||
s5 = st.add_schedule(revision_id=rid, status=store.STATUS_PROCESSING, lease_token="",
|
||||
started_at=now_kst() - timedelta(minutes=40))
|
||||
|
||||
worker.recover(st, api)
|
||||
assert st.schedules[s1]["status"] == store.STATUS_PENDING and st.schedules[s1]["retry_count"] == 1
|
||||
assert st.schedules[s2]["status"] == store.STATUS_SUCCESS
|
||||
assert st.schedules[s3]["status"] == store.STATUS_SUCCESS
|
||||
assert st.attempts[a3]["status"] == store.ATTEMPT_RECORDED
|
||||
assert st.schedules[s4]["status"] == store.STATUS_NEEDS_REVIEW
|
||||
assert st.schedules[s5]["status"] == store.STATUS_PENDING
|
||||
assert cafe.puts() == [] # 복구는 쓰지 않는다
|
||||
|
||||
|
||||
def test_worker_recover_verifies_remote_value():
|
||||
"""[05] 결과 모름 시도라도 카페24 현재값이 예약 결과와 같으면 반영됨으로 확정."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>예약</p>") # 이미 반영돼 있다
|
||||
api = fakes.FakeApi(cafe)
|
||||
rid = st.add_revision(product_no=131, html_content="<p>예약</p>", revision_type="DRAFT")
|
||||
sid = st.add_schedule(revision_id=rid, status=store.STATUS_PROCESSING, lease_token="dead",
|
||||
started_at=now_kst())
|
||||
st.expire_schedule_lease(sid)
|
||||
aid = st.start_attempt(product_no=131, schedule_id=sid, origin="SCHEDULED",
|
||||
target_digest=store.content_digest("<p>예약</p>"), target_revision_id=rid)
|
||||
worker.recover(st, api)
|
||||
assert st.schedules[sid]["status"] == store.STATUS_SUCCESS
|
||||
assert st.attempts[aid]["status"] == store.ATTEMPT_RECORDED
|
||||
|
||||
|
||||
def test_worker_late_finish_after_lease_loss_does_not_overwrite():
|
||||
"""[05] lease 를 잃은 worker 의 늦은 결과는 반영되지 않는다(token 불일치)."""
|
||||
st, _cafe, _api, sid, _ = _worker_env()
|
||||
row = st.claim_due_schedule(now=now_kst(), owner="w1", ttl_seconds=60)
|
||||
st.expire_schedule_lease(sid)
|
||||
st.claim_expired_schedules(owner="w2", ttl_seconds=60, legacy_minutes=30)
|
||||
assert st.finish_schedule(sid, token=row["lease_token"], status=store.STATUS_FAILED) is False
|
||||
assert st.schedules[sid]["status"] == store.STATUS_PROCESSING
|
||||
|
||||
# ════════════════════════════════════════════════════════════
|
||||
# 카페24 읽기 지연 보정 — 마지막 쓰기가 권위
|
||||
# ════════════════════════════════════════════════════════════
|
||||
@@ -1185,7 +1289,8 @@ def test_upload_images_and_variants_wrappers():
|
||||
assert products.list_variants(client, 7) == [{"variant_code": "P000000R000A"}]
|
||||
assert products.get_options(client, 7)["has_option"] == "T"
|
||||
assert products.update_variants(client, 7, [{"variant_code": "P000000R000A", "display": "F"}]) == [
|
||||
{"variant_code": "P000000R000A", "display": "F"}
|
||||
{"variant_code": "P000000R000A", "status": "ok", "error": "",
|
||||
"variant": {"variant_code": "P000000R000A", "display": "F"}}
|
||||
]
|
||||
sent = [c for c in client.calls if c[0] == "PUT"][-1]
|
||||
assert sent[2]["requests"][0]["variant_code"] == "P000000R000A"
|
||||
@@ -1221,6 +1326,404 @@ def test_set_main_image_uses_product_images_endpoint():
|
||||
assert products.set_main_image(client, 13, b"") == {}
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════
|
||||
# 쓰기 공통 처리(writes.write_product) — [01][02][06][07] 회귀
|
||||
# ════════════════════════════════════════════════════════════
|
||||
def _apply(st, api, html, *, fp=None, origin=store.ORIGIN_MANUAL, actor="king", **kw):
|
||||
with writes.write_lock(st, "product:131", actor=actor, purpose="t", wait_seconds=0) as lock:
|
||||
return writes.write_product(st, api, 131, lock=lock, origin=origin, actor=actor, html=html,
|
||||
base_fingerprint=fp, wait_confirm=False, **kw)
|
||||
|
||||
|
||||
def _editor_view(st, cafe):
|
||||
"""편집기가 보여줄 유효 현재값과 지문(routes_products._editor_ctx 와 같은 판정)."""
|
||||
product = cafe.get(f"/admin/products/{cafe.product_no}")["product"]
|
||||
effective, state, _ = writes.resolve_effective(st, 131, product["description"],
|
||||
fetched_updated=product.get("updated_date"))
|
||||
return effective, state, store.fingerprint(effective)
|
||||
|
||||
|
||||
def test_01_rejected_conflict_backup_does_not_mask_external_edit():
|
||||
"""[01] 충돌로 거절된 적용의 BACKUP(=외부 값 X)이 읽기 지연 근거가 되면 X 를 덮어쓴다."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
api = fakes.FakeApi(cafe)
|
||||
_apply(st, api, "<p>W1</p>") # 우리 쓰기(확인됨)
|
||||
_eff, _state, stale_fp = _editor_view(st, cafe) # 사용자 1: W1 을 보고 편집 시작
|
||||
cafe.external_edit("<p>X</p>") # 관리자에서 직접 X 로 고침
|
||||
|
||||
try:
|
||||
_apply(st, api, "<p>Y</p>", fp=stale_fp) # 사용자 1 적용 → 충돌로 거절(BACKUP X 가 남는다)
|
||||
raise AssertionError("충돌을 못 잡았다")
|
||||
except writes.WriteConflict:
|
||||
pass
|
||||
assert any(r["html_content"] == "<p>X</p>" for r in st.of_type(store.REVISION_BACKUP))
|
||||
|
||||
effective, state, fp = _editor_view(st, cafe)
|
||||
assert (effective, state) == ("<p>X</p>", store.SYNC_EXTERNAL), (effective, state)
|
||||
try:
|
||||
_apply(st, api, "<p>Y</p>", fp=stale_fp) # 같은 옛 지문으로 다시 → 여전히 충돌
|
||||
raise AssertionError("외부 수정 X 를 덮어썼다")
|
||||
except writes.WriteConflict:
|
||||
pass
|
||||
assert cafe.state["description"] == "<p>X</p>"
|
||||
_apply(st, api, "<p>Y</p>", fp=fp) # 새로 본 X 기준이면 적용된다
|
||||
assert cafe.state["description"] == "<p>Y</p>"
|
||||
|
||||
|
||||
def test_01_draft_value_is_not_treated_as_known():
|
||||
"""[01] 예약 초안(DRAFT)은 카페24에 올라간 적이 없다 — 관리자가 그 값으로 고쳐도 외부 변경."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
api = fakes.FakeApi(cafe)
|
||||
_apply(st, api, "<p>W1</p>")
|
||||
st.add_revision(product_no=131, html_content="<p>D</p>", revision_type="DRAFT")
|
||||
cafe.external_edit("<p>D</p>")
|
||||
assert _editor_view(st, cafe)[:2] == ("<p>D</p>", store.SYNC_EXTERNAL)
|
||||
|
||||
|
||||
def test_01_read_lag_still_shows_last_confirmed_write():
|
||||
"""읽기 지연 보정은 유지 — GET 이 쓰기 직전 값(A)을 돌려주면 마지막 확인된 쓰기를 보여준다."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
api = fakes.FakeApi(cafe)
|
||||
_apply(st, api, "<p>B</p>")
|
||||
cafe.stale = {**cafe.state, "description": "<p>A</p>", "updated_date": "2026-09-30T09:00:00+09:00"}
|
||||
assert _editor_view(st, cafe)[:2] == ("<p>B</p>", store.SYNC_PENDING)
|
||||
_apply(st, api, "<p>C</p>") # A→B→C 직후 GET 이 A 여도 지연
|
||||
assert _editor_view(st, cafe)[:2] == ("<p>C</p>", store.SYNC_PENDING)
|
||||
|
||||
|
||||
def test_01_revert_after_our_write_detected_by_updated_date():
|
||||
"""[01] 관리자가 우리 적용 뒤 예전 값(A)으로 되돌림 — updated_date 가 더 뒤라 외부 변경."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
api = fakes.FakeApi(cafe)
|
||||
_apply(st, api, "<p>B</p>")
|
||||
cafe.external_edit("<p>A</p>")
|
||||
assert _editor_view(st, cafe)[:2] == ("<p>A</p>", store.SYNC_EXTERNAL)
|
||||
|
||||
|
||||
def test_01_failed_write_is_not_lineage():
|
||||
"""[01] 카페24가 거절한 쓰기는 "마지막 쓰기"가 아니다."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
api = fakes.FakeApi(cafe)
|
||||
cafe.put_error = Cafe24ApiError("거절", status=422)
|
||||
try:
|
||||
_apply(st, api, "<p>B</p>")
|
||||
raise AssertionError("실패를 삼켰다")
|
||||
except writes.RemoteWriteFailed:
|
||||
pass
|
||||
assert list(st.attempts.values())[-1]["status"] == store.ATTEMPT_REMOTE_FAILED
|
||||
assert _editor_view(st, cafe)[:2] == ("<p>A</p>", store.SYNC_NONE)
|
||||
assert st.of_type(store.REVISION_MANUAL) == []
|
||||
|
||||
|
||||
def test_02_second_writer_is_serialized_and_detects_conflict():
|
||||
"""[02] 같은 편집 기준(A)으로 두 사람이 동시에 적용 — 잠금으로 순서가 생기고 뒤 사람은 충돌."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
api = fakes.FakeApi(cafe)
|
||||
fp_a = store.fingerprint("<p>A</p>")
|
||||
with writes.write_lock(st, "product:131", actor="alice", purpose="t", wait_seconds=0):
|
||||
try: # 앞 사람이 쓰는 동안 뒤 사람은 잠금을 못 잡는다
|
||||
with writes.write_lock(st, "product:131", actor="bob", purpose="t", wait_seconds=0):
|
||||
raise AssertionError("잠금이 겹쳤다")
|
||||
except writes.WriteBusy as exc:
|
||||
assert "alice" in str(exc)
|
||||
_apply(st, api, "<p>ALICE</p>", fp=fp_a, actor="alice")
|
||||
cafe.stale = {**cafe.state, "description": "<p>A</p>", "updated_date": "2026-09-30T09:00:00+09:00"}
|
||||
try: # GET 이 지연으로 A 를 돌려줘도, 마지막 확인된 쓰기(ALICE)가 기준이라 충돌
|
||||
_apply(st, api, "<p>BOB</p>", fp=fp_a, actor="bob")
|
||||
raise AssertionError("둘 다 성공했다")
|
||||
except writes.WriteConflict:
|
||||
pass
|
||||
assert cafe.state["description"] == "<p>ALICE</p>"
|
||||
|
||||
|
||||
def test_02_expired_lock_cannot_write_fencing():
|
||||
"""[02] 잠금이 만료돼 남에게 넘어간 뒤에는 PUT 하지 않는다(펜싱)."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
api = fakes.FakeApi(cafe)
|
||||
with writes.write_lock(st, "product:131", actor="slow", purpose="t", wait_seconds=0) as lock:
|
||||
st.expire_lock("product:131")
|
||||
with writes.write_lock(st, "product:131", actor="other", purpose="t", wait_seconds=0):
|
||||
pass # 만료 뒤 다른 요청이 가져갔다가 풀었다
|
||||
try:
|
||||
writes.write_product(st, api, 131, lock=lock, origin="MANUAL", actor="slow",
|
||||
html="<p>S</p>", wait_confirm=False)
|
||||
raise AssertionError("만료된 잠금으로 썼다")
|
||||
except writes.WriteBusy:
|
||||
pass
|
||||
assert cafe.puts() == []
|
||||
|
||||
|
||||
def test_02_schema_missing_refuses_to_write():
|
||||
st = fakes.MemoryStore()
|
||||
st.schema_ok = False
|
||||
try:
|
||||
with writes.write_lock(st, "product:131", actor="k", purpose="t"):
|
||||
raise AssertionError("스키마 없이 잠금을 줬다")
|
||||
except writes.WriteSetupError as exc:
|
||||
assert "005" in str(exc)
|
||||
|
||||
|
||||
def test_06_manual_backup_marks_source():
|
||||
"""[06] BACKUP 메타데이터 — 관측값(OBSERVED) / 지연 중 마지막 확인된 쓰기(LAST_WRITE)."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
api = fakes.FakeApi(cafe)
|
||||
first = _apply(st, api, "<p>B</p>")
|
||||
b1 = st.revisions[first.backup_id]
|
||||
assert (b1["html_content"], b1["source"]) == ("<p>A</p>", store.SOURCE_OBSERVED)
|
||||
cafe.stale = {**cafe.state, "description": "<p>A</p>", "updated_date": "2026-09-30T09:00:00+09:00"}
|
||||
second = _apply(st, api, "<p>C</p>")
|
||||
b2 = st.revisions[second.backup_id]
|
||||
assert (b2["html_content"], b2["source"]) == ("<p>B</p>", store.SOURCE_LAST_WRITE)
|
||||
assert b2["source_revision_id"] == first.revision_id
|
||||
|
||||
|
||||
def test_07_manual_record_failure_is_not_apply_failure():
|
||||
"""[07] PUT 성공 뒤 버전 기록 실패 — 예외 없이 record_error, 시도는 REMOTE_OK(기록 복구 대기)."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
api = fakes.FakeApi(cafe)
|
||||
st.fail_on.add("record_attempt_revision")
|
||||
out = _apply(st, api, "<p>B</p>")
|
||||
assert out.record_error and not out.revision_id
|
||||
attempt = st.attempts[out.attempt_id]
|
||||
assert attempt["status"] == store.ATTEMPT_REMOTE_OK and attempt["target_html"] == "<p>B</p>"
|
||||
# 기록이 없어도 확인된 쓰기로 본다 — 지연 중에도 B 를 보여준다
|
||||
cafe.stale = {**cafe.state, "description": "<p>A</p>", "updated_date": "2026-09-30T09:00:00+09:00"}
|
||||
assert _editor_view(st, cafe)[:2] == ("<p>B</p>", store.SYNC_PENDING)
|
||||
# 다음 쓰기 때 기록을 채운다(다시 PUT 하지 않음)
|
||||
st.fail_on.clear()
|
||||
puts = len(cafe.puts())
|
||||
cafe.stale = None
|
||||
_apply(st, api, "<p>C</p>")
|
||||
assert attempt["status"] == store.ATTEMPT_RECORDED and attempt["target_html"] == ""
|
||||
assert len(cafe.puts()) == puts + 1 # C 쓰기 한 번뿐
|
||||
|
||||
|
||||
def test_07_unknown_result_blocks_rewrite_until_verified():
|
||||
"""[07] 응답 유실 — UNKNOWN. 확정 전에는 같은 상품 상세설명을 다시 쓰지 않는다.
|
||||
카페24 값이 그 시도의 결과와 같아지면(=반영됨) 자동으로 확정한다."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
api = fakes.FakeApi(cafe)
|
||||
cafe.put_error = fakes.network_error(maybe_applied=True)
|
||||
try:
|
||||
_apply(st, api, "<p>B</p>")
|
||||
raise AssertionError("결과 모름을 성공/실패로 판정했다")
|
||||
except writes.RemoteWriteUnknown as exc:
|
||||
aid = exc.attempt_id
|
||||
assert st.attempts[aid]["status"] == store.ATTEMPT_UNKNOWN
|
||||
cafe.put_error = None
|
||||
try:
|
||||
_apply(st, api, "<p>C</p>")
|
||||
raise AssertionError("결과 모름 시도가 있는데 또 썼다")
|
||||
except writes.WriteBlocked:
|
||||
pass
|
||||
cafe.state.update(description="<p>B</p>") # 확인해 보니 반영돼 있었다
|
||||
_apply(st, api, "<p>C</p>")
|
||||
assert st.attempts[aid]["status"] == store.ATTEMPT_RECORDED
|
||||
assert [r["html_content"] for r in st.of_type(store.REVISION_MANUAL)] == ["<p>B</p>", "<p>C</p>"]
|
||||
|
||||
|
||||
def test_07_connect_error_is_definite_failure():
|
||||
"""연결조차 안 된 오류는 반영 안 됨이 확실 — UNKNOWN 이 아니라 REMOTE_FAILED."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
cafe.put_error = fakes.network_error(maybe_applied=False)
|
||||
try:
|
||||
_apply(st, fakes.FakeApi(cafe), "<p>B</p>")
|
||||
except writes.RemoteWriteFailed:
|
||||
pass
|
||||
assert list(st.attempts.values())[-1]["status"] == store.ATTEMPT_REMOTE_FAILED
|
||||
|
||||
|
||||
def test_rollback_records_rollback_revision():
|
||||
"""[13] 선택 복원은 정상 경로로 한 번 적용하고 ROLLBACK(원본 버전 표시)을 남긴다."""
|
||||
st = fakes.MemoryStore()
|
||||
cafe = fakes.FakeCafe24("<p>A</p>")
|
||||
api = fakes.FakeApi(cafe)
|
||||
first = _apply(st, api, "<p>B</p>")
|
||||
backup = first.backup_id # A
|
||||
out = _apply(st, api, st.revisions[backup]["html_content"], fp=store.fingerprint("<p>B</p>"),
|
||||
origin=store.ORIGIN_ROLLBACK, target_revision_id=backup, memo=f"버전 {backup} 복원")
|
||||
assert cafe.state["description"] == "<p>A</p>"
|
||||
rb = st.revisions[out.revision_id]
|
||||
assert rb["revision_type"] == "ROLLBACK" and rb["source_revision_id"] == backup
|
||||
assert rb["html_content"] == "<p>A</p>"
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════
|
||||
# 스냅샷 병합 · 품목 표기 · 옵션 모양 — [10][11]
|
||||
# ════════════════════════════════════════════════════════════
|
||||
def test_11_variant_snapshot_field_merge():
|
||||
at = now_kst().isoformat()
|
||||
a = store.merge_variant_snapshot({}, {"V1": {"custom_variant_code": "C1"}}, at=at)
|
||||
b = store.merge_variant_snapshot(a, {"V1": {"display": "F"}}, at=at)
|
||||
assert b["V1"]["custom_variant_code"] == "C1" and b["V1"]["display"] == "F"
|
||||
|
||||
|
||||
def test_11_empty_patch_is_not_reset_but_replace_is():
|
||||
at = now_kst().isoformat()
|
||||
a = store.merge_variant_snapshot({}, {"V1": {"display": "F"}}, at=at)
|
||||
assert store.merge_variant_snapshot(a, {}, at=at) == a
|
||||
assert store.merge_variant_snapshot(a, {}, at=at, replace=True) == {}
|
||||
|
||||
|
||||
def test_11_deleted_variant_is_not_resurrected():
|
||||
at = now_kst().isoformat()
|
||||
a = store.merge_variant_snapshot({}, {"V1": {"_deleted": True}}, at=at)
|
||||
b = store.merge_variant_snapshot(a, {"V1": {"display": "T", "custom_variant_code": "X"}}, at=at)
|
||||
assert b["V1"].get("_deleted") is True and "custom_variant_code" not in b["V1"]
|
||||
v = store.apply_variant_patch({"variant_code": "V1"}, b["V1"], section_written_at=at, grace_minutes=60)
|
||||
assert v is None
|
||||
|
||||
|
||||
def test_11_per_code_grace():
|
||||
old = (now_kst() - timedelta(hours=10)).isoformat()
|
||||
patch = {"display": "F", "_at": old}
|
||||
v = store.apply_variant_patch({"variant_code": "V1", "display": "T"}, patch,
|
||||
section_written_at=now_kst().isoformat(), grace_minutes=60)
|
||||
assert v["display"] == "T" # 그 품목 기록은 유예시간이 지났다
|
||||
|
||||
|
||||
def test_10_lagging_variant_labels_matched_by_code():
|
||||
"""[10] 옵션값 이름 변경 직후 GET 품목이 옛 이름 — 품목코드 기록으로 새 이름을 보여준다."""
|
||||
at = now_kst().isoformat()
|
||||
patch = {"options": [{"name": "색상", "value": "Jet"}], "_options_before": [[{"name": "색상", "value": "Black"}]],
|
||||
"_at": at}
|
||||
lag = store.apply_variant_patch({"variant_code": "V1", "options": [{"name": "색상", "value": "Black"}]},
|
||||
patch, section_written_at=at, grace_minutes=60)
|
||||
assert lag["options"] == [{"name": "색상", "value": "Jet"}]
|
||||
ext = store.apply_variant_patch({"variant_code": "V1", "options": [{"name": "색상", "value": "Onyx"}]},
|
||||
patch, section_written_at=at, grace_minutes=60)
|
||||
assert ext["options"] == [{"name": "색상", "value": "Onyx"}] # 관리자에서 다시 고친 이름은 믿는다
|
||||
|
||||
|
||||
def test_10_options_overlay_respects_external_change():
|
||||
at = now_kst().isoformat()
|
||||
before = {"has_option": "T", "options": [{"option_name": "색상", "option_value": [{"option_text": "Black"}]}]}
|
||||
ours = {"has_option": "T", "options": [{"option_name": "색상", "option_value": [{"option_text": "Jet"}]}]}
|
||||
other = {"has_option": "T", "options": [{"option_name": "색상", "option_value": [{"option_text": "Onyx"}]}]}
|
||||
snap = {**ours, "_before_signatures": [store.options_signature(before)]}
|
||||
assert store.overlay_options(before, snapshot=snap, written_at=at, grace_minutes=60) == (snap, True)
|
||||
assert store.overlay_options(other, snapshot=snap, written_at=at, grace_minutes=60) == (other, False)
|
||||
assert store.overlay_options(ours, snapshot=snap, written_at=at, grace_minutes=60) == (ours, False)
|
||||
|
||||
|
||||
def test_05_recovery_decision_table():
|
||||
rd = store.recovery_decision
|
||||
assert rd(None, 0)[0] == store.RECOVER_RETRY
|
||||
assert rd(None, store.MAX_RETRY)[0] == store.RECOVER_FAIL
|
||||
assert rd({"status": "RECORDED"}, 0)[0] == store.RECOVER_SUCCESS
|
||||
assert rd({"status": "REMOTE_OK"}, 0)[0] == store.RECOVER_RECORD
|
||||
assert rd({"status": "REMOTE_FAILED"}, 0)[0] == store.RECOVER_RETRY
|
||||
assert rd({"status": "STARTED"}, 0)[0] == store.RECOVER_REVIEW
|
||||
assert rd({"status": "UNKNOWN"}, 99)[0] == store.RECOVER_REVIEW # 예산과 무관하게 사람 확인
|
||||
|
||||
|
||||
def test_resolve_description_updated_date_rule():
|
||||
lw = {"html_content": "B", "created_at": now_kst(), "remote_updated_at": "2026-09-30T10:05:00+09:00"}
|
||||
digests = {store.content_digest("A")}
|
||||
newer = store.resolve_description("A", last_write=lw, known_digests=digests, grace_minutes=60,
|
||||
fetched_updated="2026-09-30T10:06:00+09:00")
|
||||
same = store.resolve_description("A", last_write=lw, known_digests=digests, grace_minutes=60,
|
||||
fetched_updated="2026-09-30T10:05:00+09:00")
|
||||
older = store.resolve_description("A", last_write=lw, known_digests=digests, grace_minutes=60,
|
||||
fetched_updated="2026-09-30T10:00:00+09:00")
|
||||
assert newer == ("A", store.SYNC_EXTERNAL)
|
||||
assert same == ("B", store.SYNC_PENDING) and older == ("B", store.SYNC_PENDING)
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════
|
||||
# 품목 일괄 수정 행별 결과 — [09]
|
||||
# ════════════════════════════════════════════════════════════
|
||||
class _ChunkClient:
|
||||
def __init__(self, fail_chunk: int, error):
|
||||
self.fail_chunk = fail_chunk
|
||||
self.error = error
|
||||
self.n = 0
|
||||
|
||||
def put(self, path, *, json=None, **kw):
|
||||
self.n += 1
|
||||
if self.n == self.fail_chunk:
|
||||
raise self.error
|
||||
return {"variants": [{"variant_code": r["variant_code"], "display": r.get("display")} for r in json["requests"]]}
|
||||
|
||||
|
||||
def _codes(n):
|
||||
return [{"variant_code": f"P0000000{i:04d}", "display": "F"} for i in range(n)]
|
||||
|
||||
|
||||
def test_09_partial_chunk_failure_reports_per_row():
|
||||
rows = products.update_variants(_ChunkClient(2, Cafe24ApiError("거절", status=422)), 7, _codes(150))
|
||||
assert [r["status"] for r in rows[:100]] == ["ok"] * 100
|
||||
assert [r["status"] for r in rows[100:]] == ["failed"] * 50
|
||||
assert rows[0]["variant"]["display"] == "F" and rows[120]["error"] == "거절"
|
||||
|
||||
|
||||
def test_09_first_chunk_failure_still_sends_second():
|
||||
client = _ChunkClient(1, fakes.network_error(maybe_applied=True))
|
||||
rows = products.update_variants(client, 7, _codes(150))
|
||||
assert client.n == 2
|
||||
assert {r["status"] for r in rows[:100]} == {"unknown"}
|
||||
assert {r["status"] for r in rows[100:]} == {"ok"}
|
||||
|
||||
|
||||
# ════════════════════════════════════════════════════════════
|
||||
# 전송 계층 — 쓰기 요청이 카페24에 닿았을 수 있는가(maybe_applied)
|
||||
# ════════════════════════════════════════════════════════════
|
||||
def _client_with(handler):
|
||||
import httpx
|
||||
|
||||
from app.integrations.cafe24 import client as client_mod
|
||||
|
||||
class _Tokens:
|
||||
def get_access_token(self):
|
||||
return "AT"
|
||||
|
||||
def force_expire(self):
|
||||
pass
|
||||
|
||||
real = httpx.Client
|
||||
transport = httpx.MockTransport(handler)
|
||||
client_mod.httpx.Client = lambda **kw: real(transport=transport, **kw)
|
||||
client_mod.time.sleep = lambda *_a, **_k: None
|
||||
return client_mod.Cafe24Client(_config(), _Tokens(), min_interval=0), (client_mod, real)
|
||||
|
||||
|
||||
def _restore(saved):
|
||||
client_mod, real = saved
|
||||
client_mod.httpx.Client = real
|
||||
|
||||
|
||||
def test_client_maybe_applied_classification():
|
||||
import httpx
|
||||
|
||||
cases = [
|
||||
("PUT", lambda req: (_ for _ in ()).throw(httpx.ReadTimeout("t", request=req)), True),
|
||||
("PUT", lambda req: (_ for _ in ()).throw(httpx.ConnectError("c", request=req)), False),
|
||||
("PUT", lambda req: httpx.Response(500, json={"error": {"message": "서버"}}), True),
|
||||
("PUT", lambda req: httpx.Response(422, json={"error": {"message": "검증"}}), False),
|
||||
("GET", lambda req: (_ for _ in ()).throw(httpx.ReadTimeout("t", request=req)), False),
|
||||
]
|
||||
for method, handler, expected in cases:
|
||||
client, saved = _client_with(handler)
|
||||
try:
|
||||
client.request(method, "/admin/products/1", json={"request": {}} if method == "PUT" else None)
|
||||
raise AssertionError("오류가 나야 한다")
|
||||
except Cafe24ApiError as exc:
|
||||
assert exc.maybe_applied is expected, (method, expected, str(exc))
|
||||
finally:
|
||||
_restore(saved)
|
||||
|
||||
|
||||
def _run_all():
|
||||
fns = [v for k, v in sorted(globals().items()) if k.startswith("test_") and callable(v)]
|
||||
for fn in fns:
|
||||
|
||||
Reference in New Issue
Block a user