cc68d5be67
- 옵션 상품 그룹을 별도 탭으로, 상품 정보 제목 행 가운데·굵게·110% - 상품 정보에 통 수량(박스)·뚜껑 수량(박스)(마이그레이션 007, 뚜껑 없으면 빈칸) - 새 발주서: 줄마다 통·뚜껑 박스 수와 공배수 힌트, 합계 박스 → 파렛트(30박스) 계산 (화면 계산만, 발주 메일은 그대로) - 메뉴를 옮겨도 달력은 sessionStorage 에서 바로 복원, 서버 값이 바뀔 때만 다시 그림 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
472 lines
31 KiB
Python
472 lines
31 KiB
Python
"""입출고 저장소 — 실제 PostgreSQL(로컬 테스트 DB 전용, INOUT_TEST_DB_URL 이 localhost 일 때만).
|
|
|
|
INOUT_TEST_DB_URL=postgresql://inout_app:<pw>@127.0.0.1:5432/inout_db python -m pytest tests/test_inout_db.py
|
|
scripts/sql/inout_db_init.sql 을 적용한 DB 에 앱 계정(inout_app)으로 붙는다 — 권한(GRANT)도 함께 확인된다.
|
|
가상의 공장·발주만 만든다(이름에 무작위 꼬리표).
|
|
"""
|
|
import os
|
|
import threading
|
|
import unittest
|
|
import uuid
|
|
from datetime import date
|
|
from urllib.parse import urlparse
|
|
|
|
DSN = os.getenv("INOUT_TEST_DB_URL", "")
|
|
ENABLED = bool(DSN) and urlparse(DSN).hostname in ("localhost", "127.0.0.1")
|
|
|
|
|
|
@unittest.skipUnless(ENABLED, "INOUT_TEST_DB_URL(localhost) not set")
|
|
class InoutDbTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
from app.modules.inout.db import InoutDBStore
|
|
|
|
cls.st = InoutDBStore(DSN)
|
|
cls.tag = uuid.uuid4().hex[:6]
|
|
cls.fid = cls.st.save_factory(factory_id=None, name=f"테스트공장-{cls.tag}", manager="김공장", contact="010-1234")
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
cls.st.close()
|
|
|
|
def order(self, lines, **over):
|
|
from app.modules.inout import store
|
|
|
|
data = store.validate_order(factory_id=over.get("factory_id", self.fid), order_date=over.get("order_date", "2026-10-16"),
|
|
due_date=over.get("due_date", "2026-10-30"), memo="",
|
|
codes=[c for c, _q in lines], quantities=[str(q) for _c, q in lines])
|
|
names = {c: f"{c} 이름" for c, _q in lines}
|
|
return self.st.create_order(data, names, by="Boss@Test.local")
|
|
|
|
def line_ids(self, oid):
|
|
return {ln["item_code"]: ln["id"] for ln in self.st.get_order(oid)["lines"]}
|
|
|
|
def test_partial_receipts_until_done(self):
|
|
o = self.order([("MT-A", 100), ("MT-B", 50)])
|
|
self.assertRegex(o["order_no"], r"^PO-261016-\d{2,}$") # 100번째부터는 세 자리
|
|
head = self.st.get_order(o["id"])
|
|
self.assertEqual((head["factory_manager"], head["factory_contact"]), ("김공장", "010-1234")) # 담당자·연락처 따로(002)
|
|
ids = self.line_ids(o["id"])
|
|
self.assertEqual(self.st.get_order(o["id"])["status"], "open")
|
|
self.st.add_receipt(o["id"], {ids["MT-A"]: "60"}, receipt_date="2026-10-20", memo="1차", confirm_over=False, by="w@x")
|
|
got = self.st.get_order(o["id"])
|
|
self.assertEqual((got["status"], got["summary"]["received"], got["summary"]["remaining"]), ("partial", 60, 90))
|
|
a = next(x for x in got["lines"] if x["item_code"] == "MT-A")
|
|
self.assertEqual((a["received"], a["remaining"], a["status"]), (60, 40, "partial"))
|
|
self.st.add_receipt(o["id"], {ids["MT-A"]: "40", ids["MT-B"]: "50"}, receipt_date="2026-10-22", memo="",
|
|
confirm_over=False, by="w@x")
|
|
got = self.st.get_order(o["id"])
|
|
self.assertEqual((got["status"], got["summary"]["remaining"], len(got["receipts"])), ("done", 0, 2))
|
|
# 전체 입고 완료 뒤엔 더 받지 않는다(2026-10-19) — 초과 확인을 해도
|
|
with self.assertRaisesRegex(ValueError, "전체 입고가 완료"):
|
|
self.st.add_receipt(o["id"], {ids["MT-A"]: "1"}, receipt_date="2026-10-23", memo="", confirm_over=True, by="w@x")
|
|
self.assertEqual(len(self.st.get_order(o["id"])["receipts"]), 2)
|
|
self.assertEqual([r["total"] for r in got["receipts"]], [60, 90])
|
|
# 진행 중 목록에서 빠지고 완료 목록에
|
|
self.assertNotIn(o["id"], [x["id"] for x in self.st.list_orders(status="active", factory_id=self.fid)])
|
|
self.assertIn(o["id"], [x["id"] for x in self.st.list_orders(status="done", factory_id=self.fid)])
|
|
|
|
def test_over_receipt_needs_confirm(self):
|
|
from app.modules.inout.db import OverReceipt
|
|
|
|
o = self.order([("MT-C", 10)])
|
|
ids = self.line_ids(o["id"])
|
|
with self.assertRaises(OverReceipt) as ctx:
|
|
self.st.add_receipt(o["id"], {ids["MT-C"]: "12"}, receipt_date="2026-10-20", memo="", confirm_over=False, by="w@x")
|
|
self.assertEqual(ctx.exception.over[0]["over"], 2)
|
|
self.assertEqual(self.st.get_order(o["id"])["summary"]["received"], 0) # 확인 전엔 아무것도 저장 안 함
|
|
self.st.add_receipt(o["id"], {ids["MT-C"]: "12"}, receipt_date="2026-10-20", memo="", confirm_over=True, by="w@x")
|
|
got = self.st.get_order(o["id"])
|
|
self.assertEqual((got["status"], got["lines"][0]["over"]), ("over", 2))
|
|
self.assertEqual([r["item_code"] for r in self.st.outstanding(factory_id=self.fid)["over"]
|
|
if r["order_id"] == o["id"]], ["MT-C"])
|
|
|
|
def test_outstanding_close_reopen_cancel(self):
|
|
o = self.order([("MT-D", 30), ("MT-E", 5)])
|
|
ids = self.line_ids(o["id"])
|
|
self.st.add_receipt(o["id"], {ids["MT-D"]: "10"}, receipt_date="2026-10-20", memo="", confirm_over=False, by="w@x")
|
|
pend = [r for r in self.st.outstanding(factory_id=self.fid)["pending"] if r["order_id"] == o["id"]]
|
|
self.assertEqual({r["item_code"]: r["remaining"] for r in pend}, {"MT-D": 20, "MT-E": 5})
|
|
self.assertTrue(self.st.outstanding(q="MT-E")["pending"])
|
|
self.st.set_closed(o["id"], closed=True, reason="공장 단종", by="boss@x")
|
|
self.assertEqual(self.st.get_order(o["id"])["status"], "closed")
|
|
self.assertFalse([r for r in self.st.outstanding(factory_id=self.fid)["pending"] if r["order_id"] == o["id"]])
|
|
with self.assertRaisesRegex(ValueError, "종결"):
|
|
self.st.add_receipt(o["id"], {ids["MT-E"]: "1"}, receipt_date="2026-10-21", memo="", confirm_over=False, by="w@x")
|
|
self.st.set_closed(o["id"], closed=False, by="boss@x")
|
|
self.assertEqual(self.st.get_order(o["id"])["status"], "partial")
|
|
with self.assertRaisesRegex(ValueError, "입고 기록이 있는"):
|
|
self.st.cancel_order(o["id"], by="boss@x")
|
|
o2 = self.order([("MT-F", 1)])
|
|
self.st.cancel_order(o2["id"], by="boss@x")
|
|
self.assertEqual(self.st.get_order(o2["id"])["status"], "cancelled")
|
|
self.assertIn(o2["id"], [x["id"] for x in self.st.list_orders(status="closed", factory_id=self.fid)])
|
|
|
|
def test_update_order_keeps_received_lines(self):
|
|
from app.modules.inout import store
|
|
|
|
o = self.order([("MT-G", 10), ("MT-H", 10)])
|
|
ids = self.line_ids(o["id"])
|
|
self.st.add_receipt(o["id"], {ids["MT-G"]: "4"}, receipt_date="2026-10-20", memo="", confirm_over=False, by="w@x")
|
|
drop_g = store.validate_order(factory_id=self.fid, order_date="2026-10-16", due_date="", memo="",
|
|
codes=["MT-H"], quantities=["10"])
|
|
with self.assertRaisesRegex(ValueError, "MT-G"):
|
|
self.st.update_order(o["id"], drop_g, {}, by="boss@x")
|
|
change = store.validate_order(factory_id=self.fid, order_date="2026-10-16", due_date="2026-11-05", memo="수정",
|
|
codes=["MT-G", "MT-I"], quantities=["3", "7"])
|
|
self.st.update_order(o["id"], change, {"MT-I": "새 제품"}, by="boss@x")
|
|
got = self.st.get_order(o["id"])
|
|
self.assertEqual([(x["item_code"], x["qty"], x["received"]) for x in got["lines"]], [("MT-G", 3, 4), ("MT-I", 7, 0)])
|
|
self.assertEqual(got["lines"][0]["status"], "over") # 수량을 입고보다 줄이면 초과로 보임
|
|
self.assertEqual((got["memo"], str(got["due_date"])), ("수정", "2026-11-05"))
|
|
|
|
def test_delete_receipt_restores_remaining(self):
|
|
o = self.order([("MT-J", 10)])
|
|
ids = self.line_ids(o["id"])
|
|
r = self.st.add_receipt(o["id"], {ids["MT-J"]: "10"}, receipt_date="2026-10-20", memo="", confirm_over=False, by="w@x")
|
|
self.st.delete_receipt(o["id"], r["id"], by="w@x")
|
|
got = self.st.get_order(o["id"])
|
|
self.assertEqual((got["status"], got["summary"]["remaining"], got["receipts"]), ("open", 10, []))
|
|
with self.assertRaises(ValueError):
|
|
self.st.delete_receipt(o["id"], r["id"], by="w@x")
|
|
|
|
def test_order_numbers_per_day_and_concurrent(self):
|
|
nos = []
|
|
lock = threading.Lock()
|
|
|
|
def make():
|
|
n = self.order([("MT-K", 1)], order_date="2026-03-03")["order_no"]
|
|
with lock:
|
|
nos.append(n)
|
|
|
|
threads = [threading.Thread(target=make) for _ in range(5)]
|
|
for t in threads:
|
|
t.start()
|
|
for t in threads:
|
|
t.join()
|
|
self.assertEqual(len(set(nos)), 5) # 동시에 만들어도 번호 겹치지 않음
|
|
self.assertTrue(all(n.startswith("PO-260303-") for n in nos))
|
|
|
|
def test_roles_and_factories(self):
|
|
self.st.set_role_members("order", ["Boss@Test.local", " a@x "], by="admin@x")
|
|
self.st.set_role_members("receive", ["w@x"], by="admin@x")
|
|
self.assertEqual(self.st.list_roles()["order"], ["a@x", "boss@test.local"])
|
|
self.assertEqual(self.st.roles_of("BOSS@test.local"), {"order"})
|
|
self.st.set_role_members("order", ["a@x"], by="admin@x") # 통째로 바꿈
|
|
self.assertEqual(self.st.list_roles()["order"], ["a@x"])
|
|
with self.assertRaisesRegex(ValueError, "같은 이름"):
|
|
self.st.save_factory(factory_id=None, name=f"테스트공장-{self.tag}".upper())
|
|
with self.assertRaisesRegex(ValueError, "발주 기록"):
|
|
self.order([("MT-L", 1)])
|
|
self.st.delete_factory(self.fid)
|
|
fid2 = self.st.save_factory(factory_id=None, name=f"빈공장-{self.tag}")
|
|
self.st.delete_factory(fid2)
|
|
self.assertNotIn(fid2, [f["id"] for f in self.st.list_factories(include_inactive=True)])
|
|
off = self.st.save_factory(factory_id=None, name=f"숨김공장-{self.tag}", is_active=False)
|
|
self.assertNotIn(off, [f["id"] for f in self.st.list_factories()])
|
|
with self.assertRaisesRegex(ValueError, "사용하지 않는 공장"):
|
|
self.order([("MT-M", 1)], factory_id=off)
|
|
|
|
# ── 003: 입고증 사진 · 공장 이메일 · Gmail 연결 · 메일 기록 ──
|
|
def test_receipt_photos_atomic_limit_delete(self):
|
|
from app.modules.inout import store
|
|
|
|
jpeg = b"\xff\xd8\xff\xe0" + b"1" * 100
|
|
o = self.order([("MT-P", 10)])
|
|
ids = self.line_ids(o["id"])
|
|
photos = store.validate_photos([("a.jpg", jpeg), ("b.jpg", jpeg)])
|
|
r = self.st.add_receipt(o["id"], {ids["MT-P"]: "4"}, receipt_date="2026-10-20", memo="", confirm_over=False,
|
|
by="w@x", photos=photos)
|
|
self.assertEqual(r["photos"], 2)
|
|
got = self.st.get_order(o["id"])
|
|
ph = got["receipts"][0]["photos"]
|
|
self.assertEqual([(p["filename"], p["content_type"], p["size_bytes"]) for p in ph], [("a.jpg", "image/jpeg", 104), ("b.jpg", "image/jpeg", 104)])
|
|
self.assertNotIn("data", ph[0]) # 목록엔 내용 없음
|
|
one = self.st.get_photo(ph[0]["id"])
|
|
self.assertEqual((bytes(one["data"]), one["order_id"]), (jpeg, o["id"]))
|
|
# 초과 확인 전에 막히면 사진도 저장 안 됨(한 트랜잭션)
|
|
from app.modules.inout.db import OverReceipt
|
|
with self.assertRaises(OverReceipt):
|
|
self.st.add_receipt(o["id"], {ids["MT-P"]: "99"}, receipt_date="2026-10-21", memo="", confirm_over=False, by="w@x",
|
|
photos=store.validate_photos([("c.jpg", jpeg)]))
|
|
self.assertEqual(sum(len(x["photos"]) for x in self.st.get_order(o["id"])["receipts"]), 2)
|
|
# 나중에 더하기 — 10장 한도는 이미 있는 장수와 합쳐서
|
|
rid = got["receipts"][0]["id"]
|
|
self.assertEqual(self.st.add_receipt_photos(o["id"], rid, [("d.jpg", jpeg)] * 8, by="w@x"), 8)
|
|
with self.assertRaisesRegex(ValueError, "10장"):
|
|
self.st.add_receipt_photos(o["id"], rid, [("e.jpg", jpeg)], by="w@x")
|
|
with self.assertRaisesRegex(ValueError, "찾을 수 없"):
|
|
self.st.add_receipt_photos(o["id"], 999999, [("e.jpg", jpeg)], by="w@x")
|
|
self.st.delete_receipt_photo(o["id"], ph[0]["id"])
|
|
self.assertIsNone(self.st.get_photo(ph[0]["id"]))
|
|
o2 = self.order([("MT-Q", 1)])
|
|
with self.assertRaisesRegex(ValueError, "찾을 수 없"): # 다른 발주서의 사진 id 로는 못 지운다
|
|
self.st.delete_receipt_photo(o2["id"], ph[1]["id"])
|
|
self.st.delete_receipt(o["id"], rid, by="w@x") # 입고를 지우면 사진도 함께
|
|
self.assertIsNone(self.st.get_photo(ph[1]["id"]))
|
|
|
|
def test_factory_email_gmail_tokens_and_mail_log(self):
|
|
fid = self.st.save_factory(factory_id=None, name=f"메일공장-{self.tag}", manager="박과장", email="a@x.com; b@y.co.kr")
|
|
f = next(x for x in self.st.list_factories() if x["id"] == fid)
|
|
self.assertEqual(f["email"], "a@x.com, b@y.co.kr")
|
|
with self.assertRaisesRegex(ValueError, "공장 이메일 형식"):
|
|
self.st.save_factory(factory_id=fid, name=f"메일공장-{self.tag}", email="not-an-email")
|
|
o = self.order([("MT-M", 3)], factory_id=fid)
|
|
self.assertEqual(self.st.get_order(o["id"])["factory_email"], "a@x.com, b@y.co.kr")
|
|
me = f"Buyer-{self.tag}@X.com"
|
|
self.assertIsNone(self.st.gmail_token(me))
|
|
self.st.save_gmail_token(me, refresh_token_enc="v1:enc1", scopes="openid email gmail.send")
|
|
self.st.save_gmail_token(me, refresh_token_enc="v1:enc2", scopes="openid email gmail.send") # 다시 연결 = 덮어씀
|
|
tok = self.st.gmail_token(me.upper())
|
|
self.assertEqual((tok["email"], tok["refresh_token_enc"]), (me.lower(), "v1:enc2"))
|
|
self.st.mark_gmail(me, error="Gmail 오류")
|
|
self.assertEqual(self.st.gmail_token(me)["last_error"], "Gmail 오류")
|
|
self.st.mark_gmail(me)
|
|
tok = self.st.gmail_token(me)
|
|
self.assertEqual(tok["last_error"], "")
|
|
self.assertIsNotNone(tok["last_used_at"])
|
|
self.st.add_order_mail(o["id"], sent_by=me, to=["a@x.com"], cc=["c@z.com"], subject="[발주] x", gmail_id="18f")
|
|
mails = self.st.get_order(o["id"])["mails"]
|
|
self.assertEqual([(m["to_addrs"], m["cc_addrs"], m["gmail_id"]) for m in mails], [("a@x.com", "c@z.com", "18f")])
|
|
self.st.delete_gmail_token(me)
|
|
self.assertIsNone(self.st.gmail_token(me))
|
|
|
|
def test_logistics_settings_and_receipt_mail_log(self):
|
|
"""005 — 물류센터 이메일·참조 설정(기본 참조 king@·bj@), 입고 사진 내용 읽기, 입고 요청 메일 기록(입고 지우면 함께)."""
|
|
from app.modules.inout import store
|
|
|
|
if not self.st.settings_ready():
|
|
self.skipTest("inout_db 005 미적용")
|
|
before = self.st.get_settings()
|
|
try:
|
|
self.assertEqual(before[store.SETTING_RECEIPT_MAIL_CC] or store.SETTING_DEFAULTS[store.SETTING_RECEIPT_MAIL_CC],
|
|
before[store.SETTING_RECEIPT_MAIL_CC])
|
|
self.st.save_settings({store.SETTING_LOGISTICS_EMAILS: "lg@x.com, lg2@x.com", store.SETTING_RECEIPT_MAIL_CC: "c@x.com"},
|
|
by="Admin@X")
|
|
got = self.st.get_settings()
|
|
self.assertEqual((got["logistics_emails"], got["receipt_mail_cc"]), ("lg@x.com, lg2@x.com", "c@x.com"))
|
|
o = self.order([("MT-R", 5)])
|
|
ids = self.line_ids(o["id"])
|
|
jpeg = b"\xff\xd8\xff\xe0" + b"1" * 50
|
|
rid = self.st.add_receipt(o["id"], {ids["MT-R"]: "5"}, receipt_date="2026-10-19", memo="", confirm_over=False, by="w@x",
|
|
photos=store.validate_photos([("a.jpg", jpeg)]))["id"]
|
|
data = self.st.receipt_photo_data(rid)
|
|
self.assertEqual([(bytes(p["data"]), p["content_type"]) for p in data], [(jpeg, "image/jpeg")])
|
|
self.assertEqual(self.st.get_order(o["id"])["receipts"][0]["mails"], [])
|
|
self.st.add_receipt_mail(rid, sent_by="W@X.com", to=["lg@x.com"], cc=["c@x.com"], subject="[입고 요청] x", gmail_id="g1")
|
|
r = self.st.get_order(o["id"])["receipts"][0]
|
|
self.assertEqual([(m["sent_by"], m["to_addrs"], m["cc_addrs"], m["gmail_id"]) for m in r["mails"]],
|
|
[("w@x.com", "lg@x.com", "c@x.com", "g1")])
|
|
self.st.delete_receipt(o["id"], rid, by="w@x") # 입고를 지우면 메일 기록도 함께(CASCADE)
|
|
self.assertEqual(self.st.get_order(o["id"])["receipts"], [])
|
|
finally:
|
|
self.st.save_settings({k: before[k] for k in store.SETTING_DEFAULTS}, by="test")
|
|
|
|
def test_times_are_kst(self):
|
|
"""TIMESTAMPTZ 는 한국 시각으로 읽힌다(화면·메일에 찍는 입력·보낸 시각) — DB 서버 시간대와 무관."""
|
|
from datetime import timedelta
|
|
|
|
o = self.order([("MT-K", 1)])
|
|
self.assertEqual(self.st.get_order(o["id"])["created_at"].utcoffset(), timedelta(hours=9))
|
|
|
|
def test_products_import_keep_exclude_snapshot(self):
|
|
"""004 — 불러오기(값 있는 상품은 그대로·없는 상품은 새 이름·지운 단품은 건너뜀), 지우기·되살리기, 발주 품목 값 사본.
|
|
끝나면 테스트 단품을 지워 상품 정보 목록을 처음 상태로 둔다(다른 테스트는 빈 목록 = 코드표를 가정할 수 있음)."""
|
|
from decimal import Decimal as D
|
|
|
|
from app.modules.inout import store
|
|
|
|
if not self.st.products_ready():
|
|
self.skipTest("inout_db 004 미적용")
|
|
T = self.tag.upper()
|
|
A, B, C = f"ZT-{T}-A", f"ZT-{T}-B", f"ZT-{T}-C"
|
|
items = [{"code": A.lower(), "name": "가"}, {"code": B, "name": "나"}, {"code": C, "name": "다"}]
|
|
before = self.st.catalog_count()
|
|
try:
|
|
r = self.st.import_products(items, by="Boss@Test.local")
|
|
self.assertEqual(r["added"], 3)
|
|
self.assertEqual(self.st.catalog_count(), before + 3)
|
|
self.st.save_products([{"code": A, **store.validate_product_values({"unit_price": "1,500", "weight_g": "24.5",
|
|
"silver_pct": "0.5"})}], by="b@x")
|
|
with self.assertRaisesRegex(ValueError, "상품 정보에 없는"):
|
|
self.st.save_products([{"code": "ZT-NOPE-" + T, "unit_price": None, "weight_g": None, "silver_pct": None}], by="b@x")
|
|
# 이름이 바뀌어 다시 불러오기 — A(값 있음)는 그대로, B(값 없음)는 새 이름
|
|
r = self.st.import_products([{"code": A, "name": "가2"}, {"code": B, "name": "나2"}, {"code": C, "name": "다"}], by="b@x")
|
|
self.assertEqual((r["added"], r["kept"], r["renamed"], r["same"]), (0, 1, 1, 1))
|
|
got = self.st.catalog_lookup([A, B])
|
|
self.assertEqual((got[A]["item_name"], got[A]["unit_price"]), ("가", D("1500.00")))
|
|
self.assertEqual(got[B]["item_name"], "나2")
|
|
# 지우기 → 목록·검색에서 빠지고 다음 불러오기에서도 건너뜀 → 되살리기
|
|
self.st.exclude_product(C, by="b@x")
|
|
self.assertNotIn(C, self.st.catalog_lookup([C]))
|
|
self.assertIn(C, [x["item_code"] for x in self.st.list_excluded()])
|
|
self.assertEqual(self.st.import_products(items, by="b@x")["excluded"], 1)
|
|
self.assertNotIn(C, self.st.catalog_lookup([C]))
|
|
self.assertEqual([x["item_code"] for x in self.st.catalog_search(f"ZT-{T}")], [A, B])
|
|
self.assertEqual([x["item_code"] for x in self.st.catalog_search("가", limit=500) if x["item_code"].startswith("ZT-" + T)], [A])
|
|
self.st.restore_product(C, by="b@x")
|
|
self.assertIn(C, self.st.catalog_lookup([C]))
|
|
self.assertNotIn(C, [x["item_code"] for x in self.st.list_excluded()])
|
|
with self.assertRaises(ValueError):
|
|
self.st.restore_product(C, by="b@x")
|
|
# 발주 품목 = 발주할 때의 값(사본) — 나중에 단가가 바뀌어도 지난 발주서는 그대로
|
|
data = store.validate_order(factory_id=self.fid, order_date="2026-10-16", due_date="", memo="",
|
|
codes=[A, B], quantities=["100", "3"])
|
|
specs = self.st.catalog_lookup([A, B])
|
|
o = self.st.create_order(data, {A: "가", B: "나2"}, by="b@x", specs=specs)
|
|
self.st.save_products([{"code": A, **store.validate_product_values({"unit_price": "2000"})}], by="b@x")
|
|
lines = {x["item_code"]: x for x in self.st.get_order(o["id"])["lines"]}
|
|
self.assertEqual((lines[A]["unit_price"], lines[A]["weight_g"], lines[A]["silver_pct"]), (D("1500.00"), D("24.50"), D("0.5000")))
|
|
self.assertIsNone(lines[B]["unit_price"])
|
|
t = store.order_totals(list(lines.values()))
|
|
self.assertEqual((t["amount"], t["missing_price"], t["silver_g"]), (D("150000.00"), 1, D("12.2500")))
|
|
# 고칠 때 새로 넣은 줄만 지금 값, 원래 있던 줄은 사본 그대로
|
|
data2 = store.validate_order(factory_id=self.fid, order_date="2026-10-16", due_date="", memo="",
|
|
codes=[A, C], quantities=["120", "1"])
|
|
self.st.update_order(o["id"], data2, {C: "다"}, by="b@x", specs=self.st.catalog_lookup([C]))
|
|
lines = {x["item_code"]: x for x in self.st.get_order(o["id"])["lines"]}
|
|
self.assertEqual((lines[A]["qty"], lines[A]["unit_price"]), (120, D("1500.00")))
|
|
self.assertEqual(set(lines), {A, C})
|
|
finally:
|
|
for code in (A, B, C):
|
|
try:
|
|
self.st.exclude_product(code, by="cleanup@x")
|
|
except ValueError:
|
|
pass
|
|
self.assertEqual(self.st.catalog_count(), before)
|
|
|
|
def test_box_quantities(self):
|
|
"""007 — 통·뚜껑 박스 입수(뚜껑 없음 = 빈칸), 검사, 목록·검색·조회에 나오고, 넣은 상품은 다시 불러와도 그대로."""
|
|
from app.modules.inout import store
|
|
|
|
if not self.st.boxes_ready():
|
|
self.skipTest("inout_db 007 미적용")
|
|
T = self.tag.upper()
|
|
A, B = f"ZB-{T}-A", f"ZB-{T}-B"
|
|
before = self.st.catalog_count()
|
|
try:
|
|
self.st.import_products([{"code": A, "name": "통"}, {"code": B, "name": "뚜껑없음"}], by="b@x")
|
|
self.assertEqual(store.validate_box_values({"body_per_box": "1,200", "lid_per_box": ""}), {"body_per_box": 1200, "lid_per_box": None})
|
|
for bad in ("0", "-3", "1.5", "abc"):
|
|
with self.assertRaises(ValueError):
|
|
store.validate_box_values({"body_per_box": bad})
|
|
empty = {"unit_price": None, "weight_g": None, "silver_pct": None}
|
|
self.st.save_products([{"code": A, **empty, **store.validate_box_values({"body_per_box": "120", "lid_per_box": "500"})},
|
|
{"code": B, **empty, **store.validate_box_values({"body_per_box": "48", "lid_per_box": ""})}], by="b@x")
|
|
got = self.st.catalog_lookup([A, B])
|
|
self.assertEqual((got[A]["body_per_box"], got[A]["lid_per_box"], got[B]["body_per_box"], got[B]["lid_per_box"]), (120, 500, 48, None))
|
|
self.assertEqual({x["item_code"]: x["body_per_box"] for x in self.st.catalog_search(f"ZB-{T}")}, {A: 120, B: 48})
|
|
self.assertEqual({x["item_code"]: x["lid_per_box"] for x in self.st.list_products() if x["item_code"] in (A, B)}, {A: 500, B: None})
|
|
self.assertEqual(self.st.import_products([{"code": B, "name": "새 이름"}], by="b@x")["kept"], 1) # 박스 입수만 넣어도 값 있는 상품
|
|
# 박스 칸을 안 보낸 저장(예전 화면)은 박스 입수를 건드리지 않는다
|
|
self.st.save_products([{"code": A, **empty}], by="b@x")
|
|
self.assertEqual(self.st.catalog_lookup([A])[A]["body_per_box"], 120)
|
|
finally:
|
|
for code in (A, B):
|
|
try:
|
|
self.st.exclude_product(code, by="cleanup@x")
|
|
except ValueError:
|
|
pass
|
|
self.assertEqual(self.st.catalog_count(), before)
|
|
|
|
def test_product_groups_colors_and_calendar(self):
|
|
"""006 — 그룹의 은 함유량·색상이 그룹 상품에 적용(그룹 없는 상품은 자기 값), 같은 이름 거절, 발주 품목 색상 사본,
|
|
메일 품목 줄 배경, 그룹 지우면 자기 값으로, 다시 불러와도 그룹·색상만 넣은 상품은 그대로. 달력 = 발주일·입고일(취소 제외)."""
|
|
from decimal import Decimal as D
|
|
|
|
from app.modules.inout import store
|
|
|
|
if not self.st.groups_ready():
|
|
self.skipTest("inout_db 006 미적용")
|
|
T = self.tag.upper()
|
|
A, B, C = f"ZG-{T}-A", f"ZG-{T}-B", f"ZG-{T}-C"
|
|
before = self.st.catalog_count()
|
|
gid = None
|
|
try:
|
|
self.st.import_products([{"code": A, "name": "가"}, {"code": B, "name": "나"}, {"code": C, "name": "다"}], by="b@x")
|
|
gid = self.st.save_group(group_id=None, by="b@x", **store.validate_group(
|
|
{"name": f"은30-{T}", "silver_pct": "30", "color": "orange", "sort_order": "1"}))
|
|
with self.assertRaisesRegex(ValueError, "같은 이름"):
|
|
self.st.save_group(group_id=None, by="b@x", **store.validate_group({"name": f"은30-{T}", "color": "blue"}))
|
|
with self.assertRaisesRegex(ValueError, "색상은"):
|
|
store.validate_group({"name": "x", "color": "pink"})
|
|
vals = store.validate_product_values({"weight_g": "50", "silver_pct": "5"})
|
|
self.st.save_products([{"code": A, **vals, "group_id": gid, "color": "blue"}, # 그룹 → 그룹 값(30%·오렌지)
|
|
{"code": B, **vals, "group_id": None, "color": "ivory"}], by="b@x") # 자기 값(5%·아이보리)
|
|
with self.assertRaisesRegex(ValueError, "없는 그룹"):
|
|
self.st.save_products([{"code": C, **vals, "group_id": 999999999, "color": "none"}], by="b@x")
|
|
got = self.st.catalog_lookup([A, B, C])
|
|
self.assertEqual((got[A]["silver_pct"], got[A]["color"], got[A]["own_silver_pct"], got[A]["own_color"], got[A]["group_name"]),
|
|
(D("30.0000"), "orange", D("5.0000"), "blue", f"은30-{T}"))
|
|
self.assertEqual((got[B]["silver_pct"], got[B]["color"], got[B]["group_id"]), (D("5.0000"), "ivory", None))
|
|
self.assertEqual(got[C]["color"], "none")
|
|
self.assertEqual([x["color"] for x in self.st.catalog_search(f"ZG-{T}")], ["orange", "ivory", "none"])
|
|
g = next(x for x in self.st.list_groups() if x["id"] == gid)
|
|
self.assertEqual((g["product_count"], g["color"]), (1, "orange"))
|
|
# 발주 = 그룹 적용 값·색상 사본, 메일 품목 줄 배경
|
|
data = store.validate_order(factory_id=self.fid, order_date="2026-10-21", due_date="", memo="",
|
|
codes=[A, B, C], quantities=["10", "10", "10"])
|
|
o = self.st.create_order(data, {A: "가", B: "나", C: "다"}, by="b@x", specs=self.st.catalog_lookup([A, B, C]))
|
|
order = self.st.get_order(o["id"])
|
|
lines = {x["item_code"]: x for x in order["lines"]}
|
|
self.assertEqual((lines[A]["silver_pct"], lines[A]["color"], lines[B]["color"], lines[C]["color"]),
|
|
(D("30.0000"), "orange", "ivory", "none"))
|
|
html = store.order_mail(order, sender_name="", sender_email="b@x")["html"]
|
|
self.assertEqual(html.count('<tr style="background:' + store.color_hex("orange") + '">'), 1)
|
|
self.assertEqual(html.count('<tr style="background:' + store.color_hex("ivory") + '">'), 1)
|
|
self.assertEqual(html.count("<tr><td"), 1) # 색없음 줄은 배경 없음
|
|
# 그룹을 바꿔도 지난 발주서는 사본 그대로 / 그룹 지우면 상품은 자기 값으로
|
|
self.st.save_group(group_id=gid, by="b@x", **store.validate_group({"name": f"은30-{T}", "silver_pct": "31", "color": "gray"}))
|
|
self.assertEqual(self.st.get_order(o["id"])["lines"][0]["color"], "orange")
|
|
self.assertEqual(self.st.catalog_lookup([A])[A]["color"], "gray")
|
|
self.assertEqual(self.st.delete_group(gid), f"은30-{T}")
|
|
gid = None
|
|
got = self.st.catalog_lookup([A])[A]
|
|
self.assertEqual((got["group_id"], got["silver_pct"], got["color"]), (None, D("5.0000"), "blue"))
|
|
# 다시 불러와도 그룹·색상만 넣은 상품은 그대로(값 있는 상품)
|
|
self.st.save_products([{"code": C, "unit_price": None, "weight_g": None, "silver_pct": None, "group_id": None,
|
|
"color": "gray"}], by="b@x")
|
|
self.assertEqual(self.st.import_products([{"code": C, "name": "다2"}], by="b@x")["kept"], 1)
|
|
# 달력 — 발주일·입고일, 취소된 발주는 빠짐
|
|
ids = self.line_ids(o["id"])
|
|
self.st.add_receipt(o["id"], {ids[A]: "4"}, receipt_date="2026-10-23", memo="", confirm_over=False, by="w@x")
|
|
cal = self.st.calendar(date(2026, 10, 1), date(2026, 10, 31))
|
|
mine = [x for x in cal["orders"] if x["id"] == o["id"]]
|
|
self.assertEqual((len(mine), mine[0]["qty"], mine[0]["kinds"], mine[0]["first_item"]), (1, 30, 3, "가"))
|
|
rec = [x for x in cal["receipts"] if x["order_id"] == o["id"]]
|
|
self.assertEqual((len(rec), rec[0]["qty"], rec[0]["receipt_date"]), (1, 4, date(2026, 10, 23)))
|
|
o2 = self.order([("MT-X", 1)], order_date="2026-10-22")
|
|
self.st.cancel_order(o2["id"], by="b@x")
|
|
self.assertFalse([x for x in self.st.calendar(date(2026, 10, 22), date(2026, 10, 22))["orders"] if x["id"] == o2["id"]])
|
|
finally:
|
|
if gid:
|
|
self.st.delete_group(gid)
|
|
for code in (A, B, C):
|
|
try:
|
|
self.st.exclude_product(code, by="cleanup@x")
|
|
except ValueError:
|
|
pass
|
|
self.assertEqual(self.st.catalog_count(), before)
|
|
|
|
|
|
def test_delete_order_cascades(self):
|
|
"""수퍼관리자 발주 삭제 — 품목·입고 기록·입고증 사진·메일 기록까지 함께 지워진다."""
|
|
o = self.order([("MT-D", 10), ("MT-E", 5)])
|
|
ids = self.line_ids(o["id"])
|
|
rid = self.st.add_receipt(o["id"], {ids["MT-D"]: "4"}, receipt_date="2026-10-20", memo="", confirm_over=False, by="w@x")
|
|
if isinstance(rid, dict):
|
|
rid = rid.get("receipt_id") or rid.get("id")
|
|
r = self.st.delete_order(o["id"])
|
|
self.assertEqual((r["order_no"], r["receipts"]), (o["order_no"], 1))
|
|
self.assertIsNone(self.st.get_order(o["id"]))
|
|
with self.st._pool.connection() as conn:
|
|
left = conn.execute("SELECT (SELECT count(*) FROM inout_order_lines WHERE order_id=%s) + "
|
|
"(SELECT count(*) FROM inout_receipts WHERE order_id=%s) AS n", (o["id"], o["id"])).fetchone()["n"]
|
|
self.assertEqual(left, 0)
|
|
with self.assertRaises(LookupError):
|
|
self.st.delete_order(o["id"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|