451b37955e
- inout_db 003: 공장 이메일, 사람별 Gmail 연결(갱신 토큰 암호문만), 발주 메일 기록, 입고증 사진(bytea). init 에도 같게.
- 발주 메일: 새 발주서 저장 → 미리보기 팝업(받는 사람 = 공장 이메일, 요약 표 HTML + 글 본문) → 사람이 [메일 발송]을
눌러야 Gmail API(gmail.send)로 본인 Gmail 에서 발송. [Gmail 연결]은 사람마다 1회 — 고른 구글 계정 = ERP 계정 확인,
APP_ENCRYPTION_KEY(AES-GCM, AAD inout:gmail:{email})로 암호화 저장. 보낸 기록, 재발송은 확인 후(resend),
연결 끊김(invalid_grant)은 토큰 삭제 후 재연결 안내.
- 입고증 사진: 입고 저장 때 첨부(브라우저가 긴 변 2000px JPEG 로 줄임 — 7.9MB → 0.8MB), 10장·10MB, 파일 머리로 형식 검사,
입고와 한 트랜잭션. 썸네일·크게 보기(←/→)·나중에 더하기·지우기, 보기는 nosniff·CSP sandbox. 초과 확인은 브라우저가 먼저(사진 유지).
- 테스트: 메일 본문·escape·받는 주소·Gmail 연결 검사·토큰 갱신/발송(가짜 구글)·암호화, 사진 검사, 실제 PostgreSQL 저장,
실제 앱 흐름(사진 업로드·보기 헤더·권한, 메일 미리보기·연결·발송·재발송·끊김). 실제 브라우저로 팝업·사진·축소 확인.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
159 lines
9.0 KiB
Python
159 lines
9.0 KiB
Python
"""입출고 003 — 발주 메일(본문·받는 주소·Gmail 연결 검사·토큰·보내기)과 입고증 사진 검사. DB·구글 없이(가짜 구글 서버)."""
|
|
import base64
|
|
import email
|
|
import json
|
|
import unittest
|
|
from datetime import date
|
|
from email import policy
|
|
from unittest.mock import patch
|
|
|
|
import httpx
|
|
|
|
from app.modules.inout import gmail
|
|
from app.modules.inout import store as s
|
|
|
|
JPEG = b"\xff\xd8\xff\xe0" + b"0" * 64
|
|
PNG = b"\x89PNG\r\n\x1a\n" + b"0" * 64
|
|
|
|
|
|
def _order(**over):
|
|
o = {"order_no": "PO-261016-01", "factory_name": "엘리화학", "factory_manager": "이석준", "order_date": date(2026, 10, 16),
|
|
"due_date": date(2026, 10, 30), "memo": "박스당 24개<포장>",
|
|
"lines": [{"item_code": "MT-0320", "item_name": "미라클 통 320ml", "qty": 5000, "memo": ""},
|
|
{"item_code": "MT-0500", "item_name": "<b>뚜껑</b>", "qty": 1200, "memo": "흰색"}]}
|
|
o.update(over)
|
|
return o
|
|
|
|
|
|
class MailContentTests(unittest.TestCase):
|
|
def test_parse_emails(self):
|
|
self.assertEqual(s.parse_emails("a@x.com, B@y.co.kr; a@X.com\nc@z.kr"), ["a@x.com", "B@y.co.kr", "c@z.kr"])
|
|
self.assertEqual(s.parse_emails(""), [])
|
|
for bad in ("abc", "a@b", "a@@b.com", "a b@c.com"):
|
|
with self.subTest(bad=bad), self.assertRaises(ValueError):
|
|
s.parse_emails(bad)
|
|
with self.assertRaisesRegex(ValueError, "입력하세요"):
|
|
s.parse_emails(" ", label="받는 사람", required=True)
|
|
with self.assertRaisesRegex(ValueError, "10개"):
|
|
s.parse_emails(",".join(f"u{i}@x.com" for i in range(11)))
|
|
|
|
def test_order_mail_summary_and_escaping(self):
|
|
m = s.order_mail(_order(), sender_name="King", sender_email="king@dbxcorp.co.kr")
|
|
self.assertEqual(m["subject"], "[발주] PO-261016-01 · 엘리화학 · 미라클 통 320ml 외 1종")
|
|
for part in ("이석준님, 안녕하세요.", "발주번호: PO-261016-01", "입고 예정일: 2026-10-30", "2종 · 총 6,200개",
|
|
"1. MT-0320 미라클 통 320ml — 5,000개", "(흰색)", "발주 담당: King (king@dbxcorp.co.kr)"):
|
|
self.assertIn(part, m["text"])
|
|
h = m["html"]
|
|
self.assertIn("<b>뚜껑</b>", h) # 제품 이름·메모의 HTML 은 글자로
|
|
self.assertIn("박스당 24개<포장>", h)
|
|
self.assertNotIn("<b>뚜껑</b>", h)
|
|
self.assertIn("6,200", h) and self.assertIn("5,000", h)
|
|
m2 = s.order_mail(_order(due_date=None, factory_manager="", memo="", lines=_order()["lines"][:1]),
|
|
sender_name="", sender_email="k@x.com")
|
|
self.assertEqual(m2["subject"], "[발주] PO-261016-01 · 엘리화학 · 미라클 통 320ml")
|
|
self.assertIn("입고 예정일: 협의", m2["text"])
|
|
self.assertTrue(m2["text"].startswith("안녕하세요."))
|
|
self.assertNotIn("요청 사항", m2["text"])
|
|
|
|
def test_build_message_utf8_and_alternative(self):
|
|
raw = gmail.build_message(sender_name="킹", sender_email="king@dbxcorp.co.kr", to=["a@x.com", "b@y.com"], cc=["c@z.com"],
|
|
subject="[발주] 테스트 · 한글", text="본문", html="<p>본문</p>")
|
|
msg = email.message_from_bytes(raw, policy=policy.default)
|
|
self.assertEqual(msg["Subject"], "[발주] 테스트 · 한글")
|
|
self.assertEqual((msg["To"], msg["Cc"]), ("a@x.com, b@y.com", "c@z.com"))
|
|
self.assertIn("king@dbxcorp.co.kr", msg["From"])
|
|
self.assertEqual([p.get_content_type() for p in msg.iter_parts()], ["text/plain", "text/html"])
|
|
|
|
|
|
class PhotoTests(unittest.TestCase):
|
|
def test_sniff(self):
|
|
self.assertEqual(s.sniff_image(JPEG), "image/jpeg")
|
|
self.assertEqual(s.sniff_image(PNG), "image/png")
|
|
self.assertEqual(s.sniff_image(b"RIFF\x00\x00\x00\x00WEBPVP8 "), "image/webp")
|
|
self.assertEqual(s.sniff_image(b"GIF89a..."), "image/gif")
|
|
self.assertEqual(s.sniff_image(b"\x00\x00\x00\x18ftypheic...."), "image/heic")
|
|
self.assertIsNone(s.sniff_image(b"%PDF-1.4"))
|
|
self.assertIsNone(s.sniff_image(b"<svg xmlns=...")) # SVG(스크립트 가능)는 받지 않는다
|
|
|
|
def test_validate(self):
|
|
out = s.validate_photos([("C:\\폰\\IMG_1.jpg", JPEG), ("empty.jpg", b""), ("b.png", PNG)])
|
|
self.assertEqual([(x["filename"], x["content_type"]) for x in out], [("IMG_1.jpg", "image/jpeg"), ("b.png", "image/png")])
|
|
with self.assertRaisesRegex(ValueError, "사진 파일"):
|
|
s.validate_photos([("x.pdf", b"%PDF-1.4")])
|
|
with self.assertRaisesRegex(ValueError, "너무 큽니다"):
|
|
s.validate_photos([("big.jpg", JPEG + b"0" * s.MAX_PHOTO_BYTES)])
|
|
with self.assertRaisesRegex(ValueError, "10장"):
|
|
s.validate_photos([("a.jpg", JPEG)] * 3, existing=8)
|
|
|
|
|
|
class GmailTests(unittest.TestCase):
|
|
def test_check_grant(self):
|
|
ok = {"userinfo": {"email": "King@dbxcorp.co.kr"}, "scope": f"openid email {gmail.GMAIL_SCOPE}", "refresh_token": "1//r"}
|
|
self.assertEqual(gmail.check_grant(ok, expected_email="king@dbxcorp.co.kr"), ("1//r", ok["scope"]))
|
|
with self.assertRaisesRegex(gmail.GmailError, "다른 구글 계정"):
|
|
gmail.check_grant({**ok, "userinfo": {"email": "me@gmail.com"}}, expected_email="king@dbxcorp.co.kr")
|
|
with self.assertRaisesRegex(gmail.GmailError, "gmail.send"):
|
|
gmail.check_grant({**ok, "scope": "openid email"}, expected_email="king@dbxcorp.co.kr")
|
|
with self.assertRaisesRegex(gmail.GmailError, "갱신 토큰"):
|
|
gmail.check_grant({**ok, "refresh_token": ""}, expected_email="king@dbxcorp.co.kr")
|
|
|
|
def test_token_encryption_roundtrip_and_aad(self):
|
|
env = {"APP_ENCRYPTION_KEY": "11" * 32, "APP_ENCRYPTION_KEY_VERSION": "1"}
|
|
with patch.dict("os.environ", env):
|
|
enc = gmail.encrypt_token("King@x.com", "1//refresh-secret")
|
|
self.assertNotIn("refresh-secret", enc)
|
|
self.assertEqual(gmail.decrypt_token("king@x.com", enc), "1//refresh-secret")
|
|
with self.assertRaises(gmail.GmailNotConnected): # 남의 이메일 이름으로는 못 푼다(AAD)
|
|
gmail.decrypt_token("other@x.com", enc)
|
|
with patch.dict("os.environ", {"APP_ENCRYPTION_KEY": ""}), self.assertRaisesRegex(gmail.GmailError, "암호화 키"):
|
|
gmail.encrypt_token("k@x.com", "r")
|
|
|
|
def _fake(self, handler):
|
|
return patch.object(gmail, "_http", lambda: httpx.Client(transport=httpx.MockTransport(handler)))
|
|
|
|
def test_send_refreshes_and_posts_raw(self):
|
|
seen = []
|
|
|
|
def handler(req):
|
|
seen.append(req)
|
|
if req.url.host == "oauth2.googleapis.com":
|
|
return httpx.Response(200, json={"access_token": "ya29.A", "expires_in": 3600})
|
|
return httpx.Response(200, json={"id": "18f-msg", "threadId": "t"})
|
|
|
|
with self._fake(handler), patch("app.main.env", side_effect=lambda k, d="": {"GOOGLE_CLIENT_ID": "cid", "GOOGLE_CLIENT_SECRET": "sec"}.get(k, d)):
|
|
gid = gmail.send("1//r", b"Subject: x\r\n\r\nbody")
|
|
self.assertEqual(gid, "18f-msg")
|
|
form = dict(x.split("=", 1) for x in seen[0].content.decode().split("&"))
|
|
self.assertEqual((form["grant_type"], form["refresh_token"], form["client_id"]), ("refresh_token", "1%2F%2Fr", "cid"))
|
|
self.assertEqual(seen[1].headers["Authorization"], "Bearer ya29.A")
|
|
self.assertEqual(base64.urlsafe_b64decode(json.loads(seen[1].content)["raw"]), b"Subject: x\r\n\r\nbody")
|
|
|
|
def test_errors(self):
|
|
env = patch("app.main.env", side_effect=lambda k, d="": {"GOOGLE_CLIENT_ID": "c", "GOOGLE_CLIENT_SECRET": "s"}.get(k, d))
|
|
revoked = lambda req: httpx.Response(400, json={"error": "invalid_grant", "error_description": "Token has been expired or revoked."}) # noqa: E731
|
|
with self._fake(revoked), env, self.assertRaisesRegex(gmail.GmailNotConnected, "끊겼습니다"):
|
|
gmail.send("1//r", b"x")
|
|
|
|
def no_api(req):
|
|
if req.url.host == "oauth2.googleapis.com":
|
|
return httpx.Response(200, json={"access_token": "a"})
|
|
return httpx.Response(403, json={"error": {"message": "Gmail API has not been used in project 1 before or it is disabled."}})
|
|
with self._fake(no_api), env, self.assertRaisesRegex(gmail.GmailError, "Gmail API 가 꺼져"):
|
|
gmail.send("1//r", b"x")
|
|
|
|
def scope(req):
|
|
if req.url.host == "oauth2.googleapis.com":
|
|
return httpx.Response(200, json={"access_token": "a"})
|
|
return httpx.Response(403, json={"error": {"message": "Request had insufficient authentication scopes."}})
|
|
with self._fake(scope), env, self.assertRaises(gmail.GmailNotConnected):
|
|
gmail.send("1//r", b"x")
|
|
|
|
def down(req):
|
|
raise httpx.ConnectError("x")
|
|
with self._fake(down), env, self.assertRaisesRegex(gmail.GmailError, "ConnectError"):
|
|
gmail.send("1//r", b"x")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|