3d2e20427c
미리보기 위 서식 막대로 고른 글자의 서식을 바꾼다(execCommand, 표·인라인 서식 유지). 서버는 밑줄·취소선 text-decoration-line 을 메일용 text-decoration 으로 바꿔 보낸다. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
443 lines
24 KiB
Python
443 lines
24 KiB
Python
"""입출고 005 — 입고 요청 메일(물류센터): 제목·본문 표·본문 안 사진(가로 600px, CID)·옵션 저장·미리보기/발송 API. DB·구글 없이."""
|
|
import email
|
|
import io
|
|
import unittest
|
|
from datetime import date, datetime
|
|
from email import policy
|
|
from unittest.mock import patch
|
|
|
|
from PIL import Image
|
|
|
|
from app.modules.inout import gmail
|
|
from app.modules.inout import store as s
|
|
|
|
|
|
def _jpeg(w, h, color=(200, 30, 30)):
|
|
buf = io.BytesIO()
|
|
Image.new("RGB", (w, h), color).save(buf, "JPEG")
|
|
return buf.getvalue()
|
|
|
|
|
|
def _png_alpha(w, h):
|
|
buf = io.BytesIO()
|
|
Image.new("RGBA", (w, h), (0, 0, 255, 128)).save(buf, "PNG")
|
|
return buf.getvalue()
|
|
|
|
|
|
HEIC = b"\x00\x00\x00\x18ftypheic" + b"0" * 64
|
|
|
|
|
|
def _order():
|
|
return {"id": 7, "order_no": "PO-261019-01", "factory_name": "엘리화학", "cancelled_at": None,
|
|
"lines": [{"id": 11, "item_code": "MW-0320", "item_name": "미라클 통 황토 320ml", "qty": 5000, "memo": "흰 뚜껑"},
|
|
{"id": 12, "item_code": "MW-0950", "item_name": "<b>950ml</b>", "qty": 10000, "memo": ""}]}
|
|
|
|
|
|
def _receipt(**over):
|
|
r = {"id": 3, "receipt_date": date(2026, 10, 19), "memo": "박스 12개<파손 없음>", "mails": [],
|
|
"lines": [{"order_line_id": 11, "item_code": "MW-0320", "item_name": "미라클 통 황토 320ml", "qty": 2000},
|
|
{"order_line_id": 12, "item_code": "MW-0950", "item_name": "<b>950ml</b>", "qty": 500}]}
|
|
r.update(over)
|
|
return r
|
|
|
|
|
|
class ReceiptMailTests(unittest.TestCase):
|
|
def test_subject_format(self):
|
|
self.assertEqual(s.receipt_mail_subject(date(2026, 10, 19)), "[입고 요청] 2026년 10월 19일(월) 입고 요청 합니다.")
|
|
self.assertEqual(s.receipt_mail_subject(date(2026, 3, 1)), "[입고 요청] 2026년 03월 01일(일) 입고 요청 합니다.")
|
|
|
|
def test_mail_images_resize_to_600_keep_ratio(self):
|
|
photos = [{"id": 1, "data": _jpeg(2000, 1500)}, {"id": 2, "data": _jpeg(400, 900)},
|
|
{"id": 3, "data": _png_alpha(1200, 300)}, {"id": 4, "data": HEIC}]
|
|
imgs, skipped = s.mail_images(photos)
|
|
self.assertEqual(skipped, 1) # HEIC 은 서버가 못 연다 → 뺌
|
|
self.assertEqual([(i["width"], i["height"]) for i in imgs], [(600, 450), (400, 900), (600, 150)])
|
|
self.assertEqual([i["cid"] for i in imgs], ["inout-photo-1@dbx", "inout-photo-2@dbx", "inout-photo-3@dbx"])
|
|
for i in imgs:
|
|
im = Image.open(io.BytesIO(i["data"]))
|
|
self.assertEqual((im.format, im.size), ("JPEG", (i["width"], i["height"])))
|
|
|
|
def test_mail_images_respects_exif_rotation(self):
|
|
im = Image.new("RGB", (1600, 1200), (10, 200, 10))
|
|
exif = im.getexif()
|
|
exif[0x0112] = 6 # 시계 방향 90° — 휴대폰 세로 사진
|
|
buf = io.BytesIO()
|
|
im.save(buf, "JPEG", exif=exif.tobytes())
|
|
imgs, _ = s.mail_images([{"id": 9, "data": buf.getvalue()}])
|
|
self.assertEqual((imgs[0]["width"], imgs[0]["height"]), (600, 800))
|
|
|
|
def test_body_table_photos_and_escaping(self):
|
|
imgs, _ = s.mail_images([{"id": 1, "data": _jpeg(2000, 1500)}])
|
|
m = s.receipt_mail(_order(), _receipt(), images=imgs, skipped=1, sender_name="김물류", sender_email="wh@dbxcorp.co.kr")
|
|
self.assertEqual(m["subject"], "[입고 요청] 2026년 10월 19일(월) 입고 요청 합니다.")
|
|
h = m["html"]
|
|
self.assertIn("입고된 아래 리스트 상품을 전산 등록 부탁드립니다.", h)
|
|
heads = [x.split("</th>")[0].split(">")[-1] for x in h.split("<thead>")[1].split("</thead>")[0].split("<th")[1:]]
|
|
self.assertEqual(heads, ["상품 이름", "상품 코드", "입고 수량", "비고"])
|
|
self.assertIn(">2,000<", h) and self.assertIn(">500<", h) and self.assertIn(">2,500<", h) # 합계
|
|
self.assertIn("흰 뚜껑", h) # 비고 = 발주 품목 줄 메모
|
|
self.assertIn("<b>950ml</b>", h) and self.assertNotIn("<b>950ml</b>", h)
|
|
self.assertIn("박스 12개<파손 없음>", h)
|
|
self.assertIn('src="cid:inout-photo-1@dbx" width="600" height="450"', h) # 본문 안 이미지(첨부 아님)
|
|
self.assertLess(h.index("<table"), h.index("cid:inout-photo-1")) # 사진은 맨 아래
|
|
self.assertIn("본문에 넣지 못한 사진 1장", h)
|
|
for part in ("입고된 아래 리스트 상품을 전산 등록 부탁드립니다.", "- 미라클 통 황토 320ml · MW-0320 · 2,000개 · 흰 뚜껑",
|
|
"합계 2,500개", "입고 담당: 김물류 (wh@dbxcorp.co.kr)"):
|
|
self.assertIn(part, m["text"])
|
|
prev = s.inline_preview_html(h, imgs)
|
|
self.assertNotIn("cid:", prev) and self.assertIn('src="data:image/jpeg;base64,', prev)
|
|
none = s.receipt_mail(_order(), _receipt(memo=""), images=[], sender_name="", sender_email="wh@x.com")
|
|
self.assertNotIn("입고 인증 사진", none["html"]) and self.assertNotIn("메모:", none["html"])
|
|
|
|
def test_build_message_inline_images_are_related_not_attachments(self):
|
|
imgs, _ = s.mail_images([{"id": 1, "data": _jpeg(800, 600)}, {"id": 2, "data": _jpeg(300, 300)}])
|
|
m = s.receipt_mail(_order(), _receipt(), images=imgs, sender_name="K", sender_email="k@dbxcorp.co.kr")
|
|
raw = gmail.build_message(sender_name="K", sender_email="k@dbxcorp.co.kr", to=["lg@x.com"],
|
|
cc=["king@dbxcorp.co.kr", "bj@dbxcorp.co.kr"], subject=m["subject"], text=m["text"],
|
|
html=m["html"], inline_images=imgs)
|
|
msg = email.message_from_bytes(raw, policy=policy.default)
|
|
self.assertEqual(msg["Cc"], "king@dbxcorp.co.kr, bj@dbxcorp.co.kr")
|
|
self.assertEqual(str(msg["Subject"]), "[입고 요청] 2026년 10월 19일(월) 입고 요청 합니다.")
|
|
self.assertEqual(msg.get_content_type(), "multipart/alternative")
|
|
related = msg.get_payload()[1]
|
|
self.assertEqual(related.get_content_type(), "multipart/related")
|
|
parts = related.get_payload()
|
|
self.assertEqual(parts[0].get_content_type(), "text/html")
|
|
self.assertEqual([p["Content-ID"] for p in parts[1:]], ["<inout-photo-1@dbx>", "<inout-photo-2@dbx>"])
|
|
self.assertTrue(all(p.get_content_disposition() == "inline" and p.get_filename() is None for p in parts[1:]))
|
|
self.assertEqual(Image.open(io.BytesIO(parts[1].get_content())).size, (600, 450))
|
|
self.assertEqual(list(msg.iter_attachments()), []) # 첨부 파일 없음
|
|
plain = gmail.build_message(sender_name="K", sender_email="k@x.com", to=["a@x.com"], cc=[], subject="x", text="t", html="<p>h</p>")
|
|
self.assertEqual(email.message_from_bytes(plain, policy=policy.default).get_payload()[1].get_content_type(), "text/html")
|
|
|
|
def test_clean_emails(self):
|
|
self.assertEqual(s.clean_emails("a@x.com;b@y.com a@x.com", label="x"), "a@x.com, b@y.com")
|
|
self.assertEqual(s.clean_emails("", label="x"), "")
|
|
with self.assertRaises(ValueError):
|
|
s.clean_emails("nope", label="물류센터")
|
|
|
|
|
|
class _Store:
|
|
"""라우터가 부르는 것만 — 입고 1건(사진 1장)·설정·Gmail 연결."""
|
|
|
|
def __init__(self):
|
|
self.mails, self.saved, self.token = [], None, {"refresh_token_enc": "enc"}
|
|
self.settings = {"logistics_emails": "lg@x.com", "receipt_mail_cc": "king@dbxcorp.co.kr, bj@dbxcorp.co.kr"}
|
|
|
|
def roles_of(self, email):
|
|
return {"receive"}
|
|
|
|
def list_roles(self):
|
|
return {"order": [], "receive": []}
|
|
|
|
def get_order(self, oid):
|
|
if oid != 7:
|
|
return None
|
|
return {**_order(), "receipts": [_receipt(mails=list(self.mails))]}
|
|
|
|
def get_settings(self):
|
|
return dict(self.settings)
|
|
|
|
def settings_ready(self):
|
|
return True
|
|
|
|
def save_settings(self, values, *, by):
|
|
self.saved = (values, by)
|
|
|
|
def receipt_photo_data(self, rid):
|
|
return [{"id": 5, "filename": "a.jpg", "content_type": "image/jpeg", "data": _jpeg(1000, 500)}]
|
|
|
|
def gmail_token(self, email):
|
|
return self.token
|
|
|
|
def mark_gmail(self, email, error=""):
|
|
pass
|
|
|
|
def delete_gmail_token(self, email):
|
|
self.token = None
|
|
|
|
def add_receipt_mail(self, rid, **kw):
|
|
self.mails.append({"sent_at": datetime(2026, 10, 19, 15, 0), "sent_by": kw["sent_by"], "to_addrs": ", ".join(kw["to"])})
|
|
self.last = (rid, kw)
|
|
|
|
|
|
class ReceiptMailApiTests(unittest.TestCase):
|
|
def setUp(self):
|
|
import importlib
|
|
|
|
from fastapi import FastAPI
|
|
from fastapi.testclient import TestClient
|
|
|
|
self.api = importlib.import_module("app.modules.inout.router")
|
|
self.st = _Store()
|
|
app = FastAPI()
|
|
app.include_router(self.api.router)
|
|
app.state.inout_store = self.st
|
|
self.user = {"email": "wh@dbxcorp.co.kr", "name": "김물류", "role": "user"}
|
|
p1 = patch.object(self.api, "_user", lambda request: self.user)
|
|
p2 = patch.object(self.api, "_is_admin", lambda user: False)
|
|
p3 = patch.object(self.api, "_callback_url", lambda request: "https://erp/inout/gmail/callback")
|
|
for p in (p1, p2, p3):
|
|
p.start()
|
|
self.addCleanup(p.stop)
|
|
self.c = TestClient(app)
|
|
|
|
def test_preview_defaults_and_photos_inline(self):
|
|
r = self.c.get("/inout/orders/7/receipts/3/mail")
|
|
self.assertEqual(r.status_code, 200, r.text)
|
|
d = r.json()
|
|
self.assertEqual((d["to"], d["cc"]), ("lg@x.com", "king@dbxcorp.co.kr, bj@dbxcorp.co.kr"))
|
|
self.assertEqual(d["subject"], "[입고 요청] 2026년 10월 19일(월) 입고 요청 합니다.")
|
|
self.assertTrue(d["connected"]) and self.assertEqual(d["photos"], 1)
|
|
self.assertIn('src="data:image/jpeg;base64,', d["html"]) and self.assertNotIn("cid:", d["html"])
|
|
self.assertIn("rmail%3D3", d["connect_url"]) # 연결 뒤 이 입고 메일 창으로 돌아옴
|
|
self.assertEqual(self.c.get("/inout/orders/7/receipts/99/mail").status_code, 404)
|
|
|
|
def test_send_records_and_resend_guard(self):
|
|
sent = []
|
|
|
|
def fake_send(refresh, raw):
|
|
sent.append(email.message_from_bytes(raw, policy=policy.default))
|
|
return "gm-1"
|
|
|
|
with patch.object(gmail, "decrypt_token", lambda e, enc: "refresh"), patch.object(gmail, "send", fake_send):
|
|
r = self.c.post("/inout/orders/7/receipts/3/mail", json={"to": "lg@x.com", "cc": "king@dbxcorp.co.kr, bj@dbxcorp.co.kr"})
|
|
self.assertEqual(r.status_code, 200, r.text)
|
|
self.assertEqual(self.st.last[0], 3)
|
|
self.assertEqual(self.st.last[1]["cc"], ["king@dbxcorp.co.kr", "bj@dbxcorp.co.kr"])
|
|
msg = sent[0]
|
|
self.assertEqual(msg["To"], "lg@x.com")
|
|
related = msg.get_payload()[1]
|
|
self.assertEqual(related.get_content_type(), "multipart/related")
|
|
self.assertEqual(Image.open(io.BytesIO(related.get_payload()[1].get_content())).size, (600, 300))
|
|
# 이미 보냄 → resend 없이는 409, resend=true 면 보냄
|
|
r = self.c.post("/inout/orders/7/receipts/3/mail", json={"to": "lg@x.com"})
|
|
self.assertEqual((r.status_code, r.json()["resend_needed"]), (409, True))
|
|
r = self.c.post("/inout/orders/7/receipts/3/mail", json={"to": "lg@x.com", "resend": True})
|
|
self.assertEqual(r.status_code, 200) and self.assertEqual(len(sent), 2)
|
|
self.assertEqual(self.c.post("/inout/orders/7/receipts/3/mail", json={"to": ""}).status_code, 400)
|
|
|
|
def test_order_role_cannot_send_receipt_mail(self):
|
|
self.st.roles_of = lambda email: {"order"}
|
|
self.assertEqual(self.c.get("/inout/orders/7/receipts/3/mail").status_code, 403)
|
|
|
|
def test_receive_role_may_connect_gmail(self):
|
|
p = self.api._perms(self.st, self.user)
|
|
self.assertEqual(self.api._require(self.st, self.user, "mail"), p) # 입고 담당도 Gmail 연결
|
|
self.st.roles_of = lambda email: set()
|
|
with self.assertRaises(Exception):
|
|
self.api._require(self.st, self.user, "mail")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|
|
|
|
|
|
class SabangnetFileTests(unittest.TestCase):
|
|
"""사방넷 입고 파일 — 1행 제목 상품코드·가용수량·불용수량, A=사방넷 코드, B=입고 수량, C=상품 이름."""
|
|
|
|
def test_rows_and_xlsx(self):
|
|
from openpyxl import load_workbook
|
|
|
|
rows, missing = s.sabangnet_rows(_receipt(), {"MW-0320": "0012345", "MW-0950": "SB-950"})
|
|
self.assertEqual(missing, [])
|
|
self.assertEqual(rows, [["0012345", 2000, "미라클 통 황토 320ml"], ["SB-950", 500, "<b>950ml</b>"]])
|
|
ws = load_workbook(io.BytesIO(s.sabangnet_xlsx(rows))).active
|
|
got = [[c.value for c in r] for r in ws.iter_rows()]
|
|
self.assertEqual(got[0], ["상품코드", "가용수량", "불용수량"])
|
|
self.assertEqual(got[1:], [["0012345", 2000, "미라클 통 황토 320ml"], ["SB-950", 500, "<b>950ml</b>"]]) # 앞자리 0 보존
|
|
self.assertEqual(ws["A2"].number_format, "@")
|
|
_rows, missing = s.sabangnet_rows(_receipt(), {"MW-0320": "0012345", "MW-0950": ""})
|
|
self.assertEqual(missing, ["MW-0950 <b>950ml</b>"])
|
|
self.assertEqual(s.sabangnet_filename(_order(), _receipt()), "사방넷_입고_20261019_PO-261019-01.xlsx")
|
|
|
|
|
|
class SabangnetApiTests(ReceiptMailApiTests):
|
|
def setUp(self):
|
|
super().setUp()
|
|
p = patch.object(self.api, "_page_user", lambda request: self.user)
|
|
p.start()
|
|
self.addCleanup(p.stop)
|
|
|
|
class Reader:
|
|
enabled, reason, last_error = True, "", ""
|
|
codes = {"MW-0320": "0012345", "MW-0950": "SB-950"}
|
|
|
|
def sabangnet_codes(self, codes):
|
|
return None if self.codes is None else {c.upper(): self.codes.get(c.upper(), "") for c in codes}
|
|
|
|
self.reader = Reader()
|
|
self.c.app.state.inout_items = self.reader
|
|
|
|
def test_download(self):
|
|
from urllib.parse import unquote
|
|
|
|
from openpyxl import load_workbook
|
|
|
|
r = self.c.get("/inout/orders/7/receipts/3/sabangnet.xlsx", follow_redirects=False)
|
|
self.assertEqual(r.status_code, 200, r.text[:200])
|
|
self.assertIn("spreadsheetml", r.headers["content-type"])
|
|
self.assertIn("사방넷_입고_20261019_PO-261019-01.xlsx", unquote(r.headers["content-disposition"]))
|
|
ws = load_workbook(io.BytesIO(r.content)).active
|
|
self.assertEqual([[c.value for c in row] for row in ws.iter_rows()],
|
|
[["상품코드", "가용수량", "불용수량"], ["0012345", 2000, "미라클 통 황토 320ml"], ["SB-950", 500, "<b>950ml</b>"]])
|
|
|
|
def test_missing_code_or_reader_down_redirects_with_message(self):
|
|
from urllib.parse import unquote_plus as unquote
|
|
|
|
self.reader.codes = {"MW-0320": "0012345"}
|
|
r = self.c.get("/inout/orders/7/receipts/3/sabangnet.xlsx", follow_redirects=False)
|
|
self.assertEqual(r.status_code, 303)
|
|
self.assertIn("사방넷 코드가 없는 상품", unquote(r.headers["location"])) and self.assertIn("MW-0950", r.headers["location"])
|
|
self.reader.codes = None
|
|
r = self.c.get("/inout/orders/7/receipts/3/sabangnet.xlsx", follow_redirects=False)
|
|
self.assertIn("코드표(itemcode_db)를 읽지 못해", unquote(r.headers["location"]))
|
|
self.assertEqual(self.c.get("/inout/orders/7/receipts/99/sabangnet.xlsx").status_code, 404)
|
|
|
|
def test_viewer_cannot_download(self):
|
|
self.st.roles_of = lambda email: set()
|
|
self.assertEqual(self.c.get("/inout/orders/7/receipts/3/sabangnet.xlsx").status_code, 403)
|
|
|
|
# 부모 클래스 테스트를 여기서 다시 돌리지 않는다
|
|
test_preview_defaults_and_photos_inline = test_send_records_and_resend_guard = None
|
|
test_order_role_cannot_send_receipt_mail = test_receive_role_may_connect_gmail = None
|
|
|
|
|
|
class OrderMailCcTests(ReceiptMailApiTests):
|
|
"""발주 메일 참조 기본값(2026-10-19) — 미리보기 참조 칸에 king@dbxcorp.co.kr, 옵션 → 공장에서 고침."""
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.st.roles_of = lambda email: {"order"}
|
|
self.st.get_order = lambda oid: {**_order(), "factory_email": "f@x.com", "factory_manager": "", "order_date": date(2026, 10, 19),
|
|
"due_date": None, "memo": "", "mails": [], "receipts": []} if oid == 7 else None
|
|
p = patch.object(self.api, "_page_user", lambda request: self.user)
|
|
p.start()
|
|
self.addCleanup(p.stop)
|
|
|
|
def test_preview_cc_default_and_setting(self):
|
|
self.assertEqual(s.SETTING_DEFAULTS["order_mail_cc"], "king@dbxcorp.co.kr")
|
|
self.st.settings["order_mail_cc"] = s.SETTING_DEFAULTS["order_mail_cc"]
|
|
d = self.c.get("/inout/orders/7/mail").json()
|
|
self.assertEqual((d["to"], d["cc"]), ("f@x.com", "king@dbxcorp.co.kr"))
|
|
self.st.settings["order_mail_cc"] = "a@x.com, b@x.com"
|
|
self.assertEqual(self.c.get("/inout/orders/7/mail").json()["cc"], "a@x.com, b@x.com")
|
|
|
|
def test_save_option_admin_only(self):
|
|
self.assertEqual(self.c.post("/inout/settings/order-mail", headers={"X-Inout-Options": "1"},
|
|
data={"order_mail_cc": "king@dbxcorp.co.kr"}).status_code, 403)
|
|
with patch.object(self.api, "_is_admin", lambda user: True):
|
|
r = self.c.post("/inout/settings/order-mail", headers={"X-Inout-Options": "1"}, data={"order_mail_cc": "king@dbxcorp.co.kr;x@y.com"})
|
|
self.assertTrue(r.json()["ok"])
|
|
self.assertEqual(self.st.saved[0], {"order_mail_cc": "king@dbxcorp.co.kr, x@y.com"})
|
|
r = self.c.post("/inout/settings/order-mail", headers={"X-Inout-Options": "1"}, data={"order_mail_cc": "nope"})
|
|
self.assertEqual(r.status_code, 400)
|
|
|
|
test_preview_defaults_and_photos_inline = test_send_records_and_resend_guard = None
|
|
test_order_role_cannot_send_receipt_mail = test_receive_role_may_connect_gmail = None
|
|
|
|
|
|
class OrderNoticeMailTests(OrderMailCcTests):
|
|
"""발주 메일을 보내면 입고 담당에게 발주 알림 메일이 같은 제목으로 따로 자동 발송(2026-10-19)."""
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.st.settings["order_mail_cc"] = "king@dbxcorp.co.kr"
|
|
self.st.roles = {"order": ["buyer@x.com"], "receive": ["wh1@x.com", "wh2@x.com"]}
|
|
self.st.list_roles = lambda: self.st.roles
|
|
self.st.order_mails = []
|
|
self.st.add_order_mail = lambda oid, **kw: self.st.order_mails.append(kw)
|
|
self.sent = []
|
|
|
|
def _send(self, fail_second=False):
|
|
def fake_send(refresh, raw):
|
|
self.sent.append(email.message_from_bytes(raw, policy=policy.default))
|
|
if fail_second and len(self.sent) == 2:
|
|
raise gmail.GmailError("구글 오류")
|
|
return "gm-%d" % len(self.sent)
|
|
|
|
with patch.object(gmail, "decrypt_token", lambda e, enc: "refresh"), patch.object(gmail, "send", fake_send):
|
|
return self.c.post("/inout/orders/7/mail", json={"to": "f@x.com", "cc": "king@dbxcorp.co.kr"})
|
|
|
|
def test_preview_shows_notice_recipients(self):
|
|
self.assertEqual(self.c.get("/inout/orders/7/mail").json()["notice_to"], ["wh1@x.com", "wh2@x.com"])
|
|
|
|
def test_notice_sent_separately_same_subject_minimal_body(self):
|
|
r = self._send()
|
|
self.assertEqual(r.status_code, 200, r.text)
|
|
self.assertIn("입고 담당 2명에게 발주 알림 메일도 보냈습니다", r.json()["message"])
|
|
factory, notice = self.sent
|
|
self.assertEqual(factory["To"], "f@x.com")
|
|
self.assertEqual((notice["To"], notice["Cc"]), ("wh1@x.com, wh2@x.com", None))
|
|
self.assertEqual(str(notice["Subject"]), str(factory["Subject"])) # 제목은 발주 메일과 같게
|
|
h = notice.get_body(("html",)).get_content()
|
|
for part in ("PO-261019-01", "2026.10.19(월)", "MW-0320", "미라클 통 황토 320ml", ">5,000<", ">10,000<", ">15,000<"):
|
|
self.assertIn(part, h)
|
|
self.assertIn("<b>950ml</b>", h)
|
|
heads = [x.split("</th>")[0].split(">")[-1] for x in h.split("<thead>")[1].split("</thead>")[0].split("<th")[1:]]
|
|
self.assertEqual(heads, ["제품 코드", "제품명", "수량"])
|
|
for absent in ("단가", "금액", "무게", "은(Ag)", "PP"):
|
|
self.assertNotIn(absent, h)
|
|
self.assertEqual(len(self.st.order_mails), 1) # 기록은 공장 메일 한 건
|
|
|
|
def test_no_receivers_or_notice_failure_does_not_block(self):
|
|
r = self._send(fail_second=True)
|
|
self.assertTrue(r.json()["ok"]) and self.assertIn("알림 메일은 보내지 못했습니다", r.json()["message"])
|
|
self.sent.clear()
|
|
self.st.roles = {"order": [], "receive": []}
|
|
self.st.order_mails.clear()
|
|
with patch.object(gmail, "decrypt_token", lambda e, enc: "refresh"), \
|
|
patch.object(gmail, "send", lambda refresh, raw: self.sent.append(raw) or "g"):
|
|
r = self.c.post("/inout/orders/7/mail", json={"to": "f@x.com"})
|
|
self.assertEqual(len(self.sent), 1)
|
|
self.assertIn("입고 담당이 옵션에 없어", r.json()["message"])
|
|
|
|
test_preview_cc_default_and_setting = test_save_option_admin_only = None
|
|
|
|
|
|
class OrderMailEditTests(OrderNoticeMailTests):
|
|
"""미리보기 창에서 고친 발주 메일 본문을 그대로 보낸다(2026-10-27) — 입고 담당 알림은 원래 내용 그대로."""
|
|
|
|
def _post(self, body):
|
|
def fake_send(refresh, raw):
|
|
self.sent.append(email.message_from_bytes(raw, policy=policy.default))
|
|
return "g"
|
|
|
|
with patch.object(gmail, "decrypt_token", lambda e, enc: "refresh"), patch.object(gmail, "send", fake_send):
|
|
return self.c.post("/inout/orders/7/mail", json={"to": "f@x.com", **body})
|
|
|
|
def test_edited_body_sent_cleaned(self):
|
|
r = self._post({"html": '<p style="color:red" onclick="x()">납기 당겨 주세요<script>alert(1)</script></p>'
|
|
'<table><tr><td style="background:#ffd8a8">MW-0320</td><td>5,500</td></tr></table>'})
|
|
self.assertEqual(r.status_code, 200, r.text)
|
|
factory, notice = self.sent
|
|
h = factory.get_body(("html",)).get_content()
|
|
self.assertIn('<p style="color:red">납기 당겨 주세요</p>', h)
|
|
self.assertIn('<td style="background:#ffd8a8">MW-0320</td>', h)
|
|
for absent in ("onclick", "script", "alert"):
|
|
self.assertNotIn(absent, h)
|
|
self.assertIn("MW-0320 | 5,500", factory.get_body(("plain",)).get_content()) # 글 버전도 고친 본문에서
|
|
self.assertIn("PO-261019-01", notice.get_body(("html",)).get_content()) # 알림은 서버가 만든 내용
|
|
|
|
def test_toolbar_formats_kept(self):
|
|
"""서식 막대(execCommand) 결과 — 크기·굵게·색·배경·밑줄(text-decoration-line → text-decoration)·링크·목록·정렬."""
|
|
h = s.clean_mail_html(
|
|
'<span style="font-size: 20px; text-decoration-line: underline;">이석준님</span>'
|
|
'<span style="font-weight: bold; color: rgb(217, 48, 37);">굵게</span>'
|
|
'<span style="background-color: rgb(255, 243, 191);">배경</span><a href="https://dbxcorp.co.kr">링크</a>'
|
|
'<a href="javascript:alert(1)">나쁜 링크</a><ol><li>하나</li></ol><div style="text-align: center;">가운데</div>')
|
|
for part in ('<span style="font-size:20px;text-decoration:underline">이석준님</span>',
|
|
'<span style="font-weight:bold;color:rgb(217, 48, 37)">굵게</span>',
|
|
'<span style="background-color:rgb(255, 243, 191)">배경</span>', '<a href="https://dbxcorp.co.kr">링크</a>',
|
|
"<a>나쁜 링크</a>", "<ol><li>하나</li></ol>", '<div style="text-align:center">가운데</div>'):
|
|
self.assertIn(part, h)
|
|
|
|
def test_empty_edited_body_rejected(self):
|
|
r = self._post({"html": "<p> <br></p>"})
|
|
self.assertEqual(r.status_code, 400)
|
|
self.assertIn("비어 있습니다", r.json()["detail"])
|
|
self.assertEqual(self.sent, [])
|
|
|
|
test_preview_shows_notice_recipients = test_notice_sent_separately_same_subject_minimal_body = None
|
|
test_no_receivers_or_notice_failure_does_not_block = None
|