feat(outreach): 안내문 발송 모듈 — 메일 일괄 발송(본인 Gmail)·인스타 DM 반자동·{이름}

- 새 모듈 app/modules/outreach(권한키 outreach, outreach_db — scripts/sql/outreach_db_init.sql, OUTREACH_DB_URL)
- 리스트 붙여넣기(주소, 이름) → 주소를 보고 메일/DM 판별(store.detect: 이메일·@계정·instagram.com·ig.me·계정명) → 미리보기 → 추가
- 메일 = 고른 줄을 한 UPDATE 로 발송중(두 번 눌러도 한 번) → 백그라운드로 본인 Gmail 한 사람에 한 통(입출고·휴가와 같은 Gmail 연결),
  설정 사진 본문 아래(cid), 보냄/실패·기록. 인스타 = 이름 넣은 문구 복사 + ig.me DM 창 → [보냄] 기록(공식 API 는 첫 DM 불가)
- 설정: 제목·본문 기본 = 미라네주방 공동구매 제안 문구, {이름}·**굵게**, 보내는 이름·끝 문구·(광고) 표시, 사진 10장
- 입출고 Gmail 콜백을 모듈 공용으로(_GMAIL_ORIGINS — vacation·outreach)
- 테스트: 판별·본문·발송(가짜 Gmail)·실제 앱·실제 PG(동시 claim 4번 = 1번)·브라우저

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-26 17:28:21 +09:00
parent e197d3deb3
commit 8c805fdd9c
23 changed files with 2279 additions and 13 deletions
+145
View File
@@ -0,0 +1,145 @@
// 안내문 발송 리스트 화면(2026-10-27) — 실제 브라우저(Chromium).
// python tests/js/render_outreach.py
// NODE_PATH=<playwright 경로> PJ_TEST_BROWSER=<Chrome 경로> node tests/js/outreach.browser.test.js
// 구분 배지(메일/DM)·걸러 보기, [DM 보내기] = 그 사람 이름이 든 문구 복사 + ig.me DM 창 새 탭, [보냄] 기록, 이름 없는 줄 표시,
// 붙여넣기 미리보기(메일/DM/오류) → 추가, 고른 메일 보내기(메일 줄만, 확인 창), 미리보기 창. 서버 API 는 테스트 안 가짜.
const fs = require("fs"), path = require("path");
const { chromium } = require("playwright");
const ROOT = path.join(__dirname, "..", "..");
const fails = [];
function check(name, cond, extra) {
if (cond) console.log("PASS " + name);
else { console.log("FAIL " + name + (extra !== undefined ? " → " + JSON.stringify(extra) : "")); fails.push(name); }
}
(async function () {
const exe = process.env.PJ_TEST_BROWSER;
const browser = await chromium.launch(exe ? { executablePath: exe } : {});
const calls = [];
try {
const ctx = await browser.newContext({ viewport: { width: 1400, height: 900 }, permissions: ["clipboard-read", "clipboard-write"] });
await ctx.route("**/*", function (r) {
const req = r.request(), u = new URL(req.url()), url = u.pathname;
if (u.host === "ig.me") return r.fulfill({ status: 200, contentType: "text/html", body: "<title>ig</title>" });
if (url.startsWith("/static/")) {
const f = path.join(ROOT, "app", url);
if (!fs.existsSync(f)) return r.fulfill({ status: 404, body: "" });
return r.fulfill({ status: 200, contentType: f.endsWith(".css") ? "text/css" : "application/javascript", body: fs.readFileSync(f) });
}
if (url.startsWith("/outreach/api/")) {
const body = req.postData() ? JSON.parse(req.postData()) : null;
calls.push({ method: req.method(), url: url, body: body });
const json = function (o, s) { return r.fulfill({ status: s || 200, contentType: "application/json", body: JSON.stringify(o) }); };
if (url === "/outreach/api/recipients/2/dm-sent") {
return json({ row: { id: 2, kind: "instagram", kind_label: "DM", handle: "mira.kitchen", address: "@mira.kitchen", name: "미라",
status: "보냄", sent_at: "2026-10-27T11:00:00+09:00", sent_via: "dm", dm_link: "https://ig.me/m/mira.kitchen",
profile_link: "https://www.instagram.com/mira.kitchen/", dm_text: "x", needs_name: false, last_error: "" } });
}
if (url === "/outreach/api/recipients/parse") {
return json({ rows: [
{ line: 1, address: "new@x.com", name: "새사람", kind: "email", kind_label: "메일", handle: "new@x.com", error: "", dup: false, exists: false },
{ line: 2, address: "@hong", name: "홍", kind: "instagram", kind_label: "DM", handle: "hong", error: "", dup: false, exists: false },
{ line: 3, address: "홍길동", name: "", kind: null, kind_label: "오류", handle: "", error: "이메일도 인스타그램 주소도 아닙니다: 홍길동", dup: false, exists: false }] });
}
if (url === "/outreach/api/recipients" && req.method() === "POST") return json({ ok: true, added: 2, existed: 0, invalid: 1 });
if (url === "/outreach/api/send") return json({ ok: true, queued: body.ids.length }, 202);
if (url === "/outreach/api/recipients/1/preview") {
return json({ subject: "누적매출 300억", html: "<p>안녕하세요, 김철수님.</p>", text: "안녕하세요, 김철수님.", kind: "email", to: "kim@miras.co.kr", sender_name: "미라네주방" });
}
if (url === "/outreach/api/recipients" && req.method() === "GET") {
const data = JSON.parse(fs.readFileSync(path.join(__dirname, ".out", "outreach.html"), "utf8")
.match(/<script type="application\/json" id="otr-data">([\s\S]*?)<\/script>/)[1]);
return json(data);
}
return json({});
}
r.fulfill({ status: 200, contentType: "text/html; charset=utf-8", body: fs.readFileSync(path.join(__dirname, ".out", "outreach.html"), "utf8") });
});
const p = await ctx.newPage();
p.on("dialog", function (d) { d.accept(); });
// http 테스트 주소는 보안 컨텍스트가 아니라 navigator.clipboard 가 없다 → 화면이 쓰는 예비 복사(execCommand)를 잡아 본다
// (운영은 https 라 navigator.clipboard.writeText 로 복사)
await p.addInitScript(function () {
const orig = document.execCommand.bind(document);
document.execCommand = function (cmd) {
if (cmd === "copy") { const a = document.activeElement; window.__copied = a && "value" in a ? a.value : ""; return true; }
return orig.apply(document, arguments);
};
});
await p.goto("http://erp.test/outreach/");
await p.waitForTimeout(200);
const rowsInfo = function () {
return p.evaluate(function () {
return Array.from(document.querySelectorAll("#otr-tbody tr")).map(function (tr) {
return { id: +tr.dataset.id, kind: tr.querySelector(".otr-kind").textContent, name: tr.querySelector(".otr-name").value,
status: tr.querySelector(".otr-st").textContent, noname: tr.classList.contains("is-noname"),
acts: Array.from(tr.querySelectorAll("[data-act]")).map(function (b) { return b.dataset.act; }) };
});
});
};
const r0 = await rowsInfo();
check("구분 배지 = 주소를 보고 메일/DM, DM 줄은 [DM 보내기]·[보냄], 메일 줄은 [미리보기]",
JSON.stringify(r0.map(function (r) { return r.kind; })) === '["메일","DM","메일","메일"]' &&
JSON.stringify(r0[1].acts) === '["dm","dm-sent"]' && JSON.stringify(r0[0].acts) === '["preview"]', r0);
check("본문 {이름} 인데 이름 없는 줄 = 표시", r0[2].noname && !r0[0].noname, r0[2]);
const cnt = await p.evaluate(function () {
const o = {}; document.querySelectorAll("[data-cnt]").forEach(function (n) { o[n.dataset.cnt] = n.textContent; }); return o;
});
check("걸러 보기 개수", cnt.all === "4" && cnt.email === "3" && cnt.instagram === "1" && cnt["보냄"] === "1", cnt);
await p.click('[data-filter="instagram"]');
check("DM 만 보기", (await rowsInfo()).length === 1);
await p.click('[data-filter="all"]');
// DM 보내기 — 문구 복사 + DM 창
const [igPage] = await Promise.all([ctx.waitForEvent("page"), p.click('tr[data-id="2"] [data-act="dm"]')]);
await igPage.waitForLoadState().catch(function () {});
const clip = await p.evaluate(function () {
return navigator.clipboard ? navigator.clipboard.readText() : (window.__copied || "");
});
check("[DM 보내기] = ig.me/m/계정 새 탭", /ig\.me\/m\/mira\.kitchen/.test(igPage.url()), igPage.url());
check("[DM 보내기] = 이름이 들어간 DM 문구 복사(별표 없음)", clip.indexOf("안녕하세요, 미라님.") === 0 && clip.indexOf("**") < 0 &&
clip.indexOf("'미라네주방'입니다") > 0, clip.slice(0, 80));
await igPage.close();
await p.click('tr[data-id="2"] [data-act="dm-sent"]');
await p.waitForTimeout(100);
const r1 = await rowsInfo();
check("[보냄] → 보냄, 버튼 빠짐", r1[1].status === "보냄" && JSON.stringify(r1[1].acts) === '["dm"]' &&
calls.some(function (c) { return c.url === "/outreach/api/recipients/2/dm-sent"; }), r1[1]);
// 미리보기 창
await p.click('tr[data-id="1"] [data-act="preview"]');
await p.waitForTimeout(100);
const pv = await p.evaluate(function () {
return { shown: !document.getElementById("otr-preview").hidden, subject: document.getElementById("otr-pv-subject").textContent,
doc: document.getElementById("otr-pv-frame").srcdoc };
});
check("미리보기 창 = 제목·본문(그 사람 이름)", pv.shown && /누적매출 300억/.test(pv.subject) && /김철수님/.test(pv.doc), pv);
await p.keyboard.press("Escape");
// 고른 메일 보내기 — 전부 고르면 메일·대기만(1·3), DM·보냄 빠짐
await p.check("#otr-check-all");
check("고른 줄 수 표시", /고른 줄 4 · 보낼 메일 2/.test(await p.textContent("#otr-selected")), await p.textContent("#otr-selected"));
await p.click("#otr-send");
await p.waitForTimeout(200);
const sendCall = calls.find(function (c) { return c.url === "/outreach/api/send"; });
check("고른 메일 보내기 → 메일·대기 줄만 보냄", !!sendCall && JSON.stringify(sendCall.body.ids) === "[1,3]", sendCall);
// 리스트 추가 — 미리보기(판별) → 추가
await p.click("#otr-add-open");
await p.fill("#otr-add-text", "new@x.com 새사람\n@hong 홍\n홍길동");
check("미리보기 전엔 [리스트에 추가] 꺼짐", await p.isDisabled("#otr-add-save"));
await p.click("#otr-add-preview");
await p.waitForTimeout(100);
const prev = await p.evaluate(function () {
return { kinds: Array.from(document.querySelectorAll("#otr-add-result .otr-kind")).map(function (n) { return n.textContent; }),
sum: document.getElementById("otr-add-sum").textContent, err: document.querySelector("#otr-add-result .otr-err").textContent };
});
check("붙여넣기 미리보기 = 메일/DM/오류 + 요약", JSON.stringify(prev.kinds) === '["메일","DM","오류"]' &&
/새로 2명 \(메일 1 · DM 1\) · 오류 1줄/.test(prev.sum) && /인스타그램 주소도 아닙니다/.test(prev.err), prev);
await p.click("#otr-add-save");
await p.waitForTimeout(150);
const add = calls.find(function (c) { return c.method === "POST" && c.url === "/outreach/api/recipients"; });
check("[리스트에 추가] → 붙여 넣은 글 그대로 서버로, 창 닫힘", !!add && /new@x\.com 새사람/.test(add.body.text) &&
await p.evaluate(function () { return document.getElementById("otr-add").hidden; }), add);
} finally {
await browser.close();
}
if (fails.length) { console.log("\n" + fails.length + " FAILED"); process.exit(1); }
console.log("\nALL PASS");
})().catch(function (e) { console.error(e); process.exit(1); });
+44
View File
@@ -0,0 +1,44 @@
"""안내문 발송 화면(index.html)을 진짜 ERP 셸로 렌더 — 브라우저 테스트용(2026-10-27).
python tests/js/render_outreach.py # → tests/js/.out/outreach.html
화면 데이터는 실제 router._view 로 만든다(저장소 없이 줄만 가짜).
"""
from __future__ import annotations
import os
import sys
import jinja2
ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, ROOT)
OUT_DIR = os.path.join(ROOT, "tests", "js", ".out")
from app.modules.outreach import store # noqa: E402
from app.modules.outreach.router import _view # noqa: E402
def main() -> None:
os.makedirs(OUT_DIR, exist_ok=True)
env = jinja2.Environment(loader=jinja2.FileSystemLoader([
os.path.join(ROOT, "app", "templates"), os.path.join(ROOT, "app", "modules", "outreach", "templates")]), autoescape=True)
t = {**store.normalize_template(None), "updated_by": "", "updated_at": "", "is_default": True}
base = {"id": 0, "memo": "", "status": "대기", "sent_at": "", "sent_by": "", "sent_via": "", "last_error": ""}
raw = [
{**base, "id": 1, "kind": "email", "handle": "kim@miras.co.kr", "address": "kim@miras.co.kr", "name": "김철수"},
{**base, "id": 2, "kind": "instagram", "handle": "mira.kitchen", "address": "@mira.kitchen", "name": "미라"},
{**base, "id": 3, "kind": "email", "handle": "noname@miras.co.kr", "address": "noname@miras.co.kr", "name": ""},
{**base, "id": 4, "kind": "email", "handle": "done@miras.co.kr", "address": "done@miras.co.kr", "name": "보냄씨",
"status": "보냄", "sent_at": "2026-10-27T10:00:00+09:00", "sent_via": "gmail"},
]
ctx = {"user": {"email": "me@miras.co.kr", "name": "나", "picture": ""}, "is_admin": False, "nav_items": [],
"page_title": "안내문 발송", "page_subtitle": "", "template": t, "images": [], "rows": [_view(r, t) for r in raw],
"logs": [], "gmail": {"available": True, "connected": True, "email": "me@miras.co.kr"}, "msg": ""}
with open(os.path.join(OUT_DIR, "outreach.html"), "w", encoding="utf-8") as f:
f.write(env.get_template("outreach/index.html").render(**ctx))
if __name__ == "__main__":
main()
+437
View File
@@ -0,0 +1,437 @@
"""안내문 발송(outreach, 2026-10-27).
1) store — 주소 판별(메일/인스타), 붙여넣기 해석, {이름}·(광고)·끝 문구, 메일 HTML(escape·굵게·링크·사진), DM 글.
2) send.send_batch — 본인 Gmail 로 한 사람에 한 통, 이름 없음·연결 끊김·한 사람 실패 처리(가짜 Gmail).
3) 실제 앱(격리된 하위 프로세스, 가짜 저장소) — 메뉴·권한·설정 필요 안내·화면·API·Gmail 없을 때 409.
4) 실제 PostgreSQL(OUTREACH_TEST_DB_URL 이 localhost 일 때만) — 추가·중복·두 번 눌러도 한 번(claim)·기록·설정·사진.
"""
import os
import subprocess
import sys
import tempfile
import unittest
import uuid
from pathlib import Path
from unittest.mock import patch
from urllib.parse import urlparse
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from app.modules.outreach import send, store # noqa: E402
DSN = os.getenv("OUTREACH_TEST_DB_URL", "")
DB_ENABLED = bool(DSN) and urlparse(DSN).hostname in ("localhost", "127.0.0.1")
class DetectParseTests(unittest.TestCase):
def test_detect(self):
ok = {"Kim@Miras.co.kr": ("email", "kim@miras.co.kr"), "mailto:a@b.com": ("email", "a@b.com"),
"@mira.kitchen": ("instagram", "mira.kitchen"), "mira_kitchen": ("instagram", "mira_kitchen"),
"https://www.instagram.com/Lee_S/?hl=ko": ("instagram", "lee_s"), "instagram.com/park.j": ("instagram", "park.j"),
"ig.me/m/hong": ("instagram", "hong"), "https://instagr.am/choi": ("instagram", "choi")}
for a, (k, h) in ok.items():
d = store.detect(a)
self.assertEqual((d["kind"], d["handle"]), (k, h), a)
for bad in ("", "홍길동", "a@b", "bad..name", ".dot", "instagram.com/p/abc123", "https://instagram.com/reel/x", "12345", "a" * 31):
self.assertIsNone(store.detect(bad)["kind"], bad)
def test_parse_bulk(self):
rows = store.parse_bulk("kim@miras.co.kr, 김철수\n홍길동\t@hong.gd\n\n# 주석\nhttps://instagram.com/lee_s 이수진\n"
"@hong.gd 홍길동 또\n박지성 park_js\n주소없음 홍\n")
got = [(r["kind"], r["handle"], r["name"], r["dup"]) for r in rows]
self.assertEqual(got, [("email", "kim@miras.co.kr", "김철수", False), ("instagram", "hong.gd", "홍길동", False),
("instagram", "lee_s", "이수진", False), ("instagram", "hong.gd", "홍길동 또", True),
("instagram", "park_js", "박지성", False), (None, "", "홍", False)])
self.assertEqual([r["line"] for r in rows], [1, 2, 5, 6, 7, 8])
class RenderTests(unittest.TestCase):
T = store.normalize_template({"subject": "{이름}님께 제안", "body": "안녕하세요, {이름}님.\n**미라네주방**입니다.\nhttps://miras.co.kr/",
"footer": "수신 거부는 회신", "ad_label": True, "sender_name": "미라네주방"})
def test_default_template_is_users_text(self):
d = store.DEFAULT_TEMPLATE
self.assertEqual(d["subject"], "누적매출 300억. 800만개 판매 신화 미라클통 '미라네주방'입니다.")
self.assertTrue(d["body"].startswith("안녕하세요, {이름}님.\n주방의 본질을 지키며"))
self.assertTrue(d["body"].rstrip().endswith("미라네주방 팀 드림\nhttps://miras.co.kr/"))
self.assertEqual(d["body"].count("{이름}"), 6)
self.assertTrue(store.needs_name(d))
def test_subject_text_html_dm(self):
self.assertEqual(store.subject_for(self.T, "김철수"), "(광고) 김철수님께 제안")
self.assertEqual(store.plain_text(self.T, "김철수"), "안녕하세요, 김철수님.\n미라네주방입니다.\nhttps://miras.co.kr/\n\n수신 거부는 회신")
h = store.html_body(self.T, "<script>x</script>", ["c1@dbx", "c2@dbx"])
self.assertIn("&lt;script&gt;x&lt;/script&gt;님", h)
self.assertNotIn("<script>", h)
self.assertIn("<b>미라네주방</b>", h)
self.assertIn('<a href="https://miras.co.kr/"', h)
self.assertEqual(h.count('src="cid:'), 2)
self.assertEqual(store.dm_link("mira.kitchen"), "https://ig.me/m/mira.kitchen")
class FakeDB:
def __init__(self, template=None, images=()):
self.t = store.normalize_template(template)
self.images = list(images)
self.done = []
def get_template(self):
return dict(self.t)
def list_images(self, with_data=False):
return self.images
def finish_send(self, rid, *, ok, via, by, subject, error=""):
self.done.append((rid, ok, via, by, subject, error))
class FakeInout:
def __init__(self, connected=True):
self.tok = {"me@miras.co.kr": {"refresh_token_enc": "enc"}} if connected else {}
self.deleted, self.marked = [], []
def gmail_token(self, email):
return self.tok.get(email)
def delete_gmail_token(self, email):
self.deleted.append(email)
def mark_gmail(self, email, error=""):
self.marked.append(email)
class SendBatchTests(unittest.TestCase):
USER = {"email": "me@miras.co.kr", "name": "나"}
ROWS = [{"id": 1, "handle": "a@x.com", "name": "에이"}, {"id": 2, "handle": "b@x.com", "name": ""},
{"id": 3, "handle": "c@x.com", "name": "씨"}]
def _run(self, db, inout, fail_on=None, exc=None):
from app.modules.inout import gmail
sent = []
def fake_send(refresh, raw):
text = raw.decode("utf-8", "replace")
to = next(r["handle"] for r in self.ROWS if r["handle"] in text.split("Subject:")[0])
if fail_on and to == fail_on:
raise exc
sent.append((refresh, to, raw))
return "gid"
with patch.object(gmail, "decrypt_token", return_value="R"), patch.object(gmail, "send", side_effect=fake_send):
res = send.send_batch(db, inout, rows=[dict(r) for r in self.ROWS], user=self.USER, gap=0)
return res, sent
def test_sends_one_each_skips_no_name(self):
import email as em
import email.policy # noqa: F401
db = FakeDB(images=[{"id": 9, "data": b"\xff\xd8jpeg"}])
res, sent = self._run(db, FakeInout())
self.assertEqual(res, {"sent": 2, "failed": 1})
self.assertEqual([s[1] for s in sent], ["a@x.com", "c@x.com"])
msg = em.message_from_bytes(sent[0][2], policy=em.policy.default)
self.assertIn("me@miras.co.kr", msg["From"])
self.assertEqual(msg["To"], "a@x.com")
html = next(p for p in msg.walk() if p.get_content_type() == "text/html").get_content()
self.assertIn("안녕하세요, 에이님.", html)
self.assertIn("cid:outreach-9@dbx", html)
self.assertTrue(any(p.get("Content-ID") == "<outreach-9@dbx>" for p in msg.walk()))
self.assertEqual([(d[0], d[1]) for d in db.done], [(1, True), (2, False), (3, True)])
self.assertIn("이름 없음", db.done[1][5])
def test_not_connected_fails_all(self):
db = FakeDB()
res, sent = self._run(db, FakeInout(connected=False))
self.assertEqual((res, sent), ({"sent": 0, "failed": 3}, []))
self.assertTrue(all(not d[1] and "Gmail 이 연결되지" in d[5] for d in db.done))
def test_disconnect_midway_stops_rest_and_one_bad_address_continues(self):
from app.modules.inout import gmail
db, inout = FakeDB({"body": "본문"}), FakeInout()
res, _ = self._run(db, inout, fail_on="a@x.com", exc=gmail.GmailNotConnected("끊김"))
self.assertEqual(res, {"sent": 0, "failed": 3})
self.assertEqual(inout.deleted, ["me@miras.co.kr"])
db2 = FakeDB({"body": "본문"})
res2, sent2 = self._run(db2, FakeInout(), fail_on="a@x.com", exc=gmail.GmailError("주소 오류"))
self.assertEqual(res2, {"sent": 2, "failed": 1}) # {이름} 없는 본문 = 이름 없어도 보냄
self.assertEqual([s[1] for s in sent2], ["b@x.com", "c@x.com"])
# ── 실제 앱 ─────────────────────────────────────────────
PRELUDE = '''
from unittest.mock import patch
from fastapi.testclient import TestClient
import app.main as main
from app.modules.outreach import store as ostore
from app.modules.outreach import send as osend
def U(email, role="user", outreach=True):
return {"email": email, "name": email.split("@")[0], "role": role, "is_super_admin": False, "modules": {"outreach": outreach}}
who = {"u": None}
me, other = U("me@miras.co.kr"), U("x@miras.co.kr", outreach=False)
users = [me, other]
batches = []
class Store:
def __init__(self):
self.t = ostore.normalize_template(None); self.rows = []; self.seq = 0; self.saved = None
def get_template(self):
return {**self.t, "updated_by": "", "updated_at": "", "is_default": self.saved is None}
def save_template(self, value, by): # db.save_template 과 같은 검사
t = ostore.normalize_template(value)
if not t["subject"] or not t["body"].strip(): raise ValueError("메일 제목·본문을 쓰세요.")
self.t = t; self.saved = by; return self.get_template()
def list_images(self, with_data=False): return []
def list_logs(self, limit=200): return []
def list_recipients(self): return [dict(r) for r in self.rows]
def get_recipient(self, rid): return next((dict(r) for r in self.rows if r["id"] == rid), None)
def add_recipients(self, rows, by):
out = {"added": 0, "existed": 0, "invalid": 0}
for r in rows:
d = ostore.detect(r["address"])
if not d["kind"]: out["invalid"] += 1; continue
if any(x["kind"] == d["kind"] and x["handle"] == d["handle"] for x in self.rows): out["existed"] += 1; continue
self.seq += 1
self.rows.append({"id": self.seq, "kind": d["kind"], "handle": d["handle"], "address": r["address"], "name": r["name"],
"memo": "", "status": "대기", "sent_at": "", "sent_by": "", "sent_via": "", "last_error": ""})
out["added"] += 1
return out
def update_recipient(self, rid, name=None, memo=None, status=None):
r = next(x for x in self.rows if x["id"] == rid)
if name is not None: r["name"] = name
if status is not None: r["status"] = status
return dict(r)
def delete_recipients(self, ids):
n = len(self.rows); self.rows = [r for r in self.rows if r["id"] not in ids]; return n - len(self.rows)
def claim_for_send(self, ids):
got = [r for r in self.rows if r["id"] in ids and r["kind"] == "email" and r["status"] in ("대기", "실패")]
for r in got: r["status"] = "발송중"
return [dict(r) for r in got]
def mark_dm_sent(self, rid, by, subject):
r = next(x for x in self.rows if x["id"] == rid)
if r["kind"] != "instagram": raise ValueError("메일 줄은 [일괄 발송]으로 보냅니다.")
r.update(status="보냄", sent_via="dm", sent_by=by); return dict(r)
class Inout:
def __init__(self, on): self.on = on
def gmail_token(self, email): return {"refresh_token_enc": "x"} if self.on else None
st = Store()
def run(body, connected=False, configured=True):
main.app.state.outreach_store = st if configured else None
main.app.state.inout_store = Inout(connected)
with patch.object(main, "get_current_user_record", side_effect=lambda r: who["u"]), \\
patch.object(main, "get_session_user", side_effect=lambda r: who["u"]), \\
patch.object(main.user_store, "get", side_effect=lambda e: who["u"]), \\
patch.object(main.user_store, "list_all", side_effect=lambda: users), \\
patch.object(osend, "send_batch", side_effect=lambda *a, **kw: batches.append([r["id"] for r in kw["rows"]])), \\
patch("app.modules.inout.gmail.configured", return_value=True):
body(TestClient(main.app, follow_redirects=False))
'''
def _run(code: str) -> subprocess.CompletedProcess:
env = dict(os.environ)
for key in ("ASSET", "CAFE24", "CUPANG", "VACATION", "PROJECT", "DISPATCH", "PERFORMANCE", "MALAYSIA_STOCK",
"ITEMCODE", "EXPENSE", "INOUT", "OUTREACH"):
env[key + "_DB_URL"] = ""
env.update(SESSION_SECRET_KEY="local-outreach-test-only", SESSION_COOKIE_SECURE="false", PERFORMANCE_AUTO_SYNC="false",
PYTHONIOENCODING="utf-8")
with tempfile.TemporaryDirectory(prefix="outreach-web-") as directory:
env["DATA_DIR"] = directory
return subprocess.run([sys.executable, "-c", PRELUDE + code], cwd=ROOT, env=env, capture_output=True,
text=True, encoding="utf-8", timeout=120)
class OutreachWebTests(unittest.TestCase):
def test_registered_permission_and_unconfigured(self):
res = _run('''
from app.store import MODULE_KEYS
def body(c):
assert "outreach" in MODULE_KEYS and main.MODULE_LABELS["outreach"] == "안내문 발송"
who["u"] = me
assert any(x["key"] == "outreach" for x in main.build_erp_nav(me, active="outreach"))
r = c.get("/outreach/")
assert r.status_code == 503 and "OUTREACH_DB_URL" in r.text, r.status_code
assert c.get("/outreach/health").json() == {"status": "not_configured"}
who["u"] = other
assert c.get("/outreach/").status_code == 403
assert c.post("/outreach/api/recipients", json={"text": "a@b.com"}).status_code == 403
print("OK")
run(body, configured=False)
''')
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
def test_flow(self):
res = _run('''
def body(c):
who["u"] = me
t = c.get("/outreach/").text
assert "안내문 발송" in t and "누적매출 300억" in t and "Gmail 연결" in t and "고른 메일 보내기" in t
# 설정 — 기본 문구, 저장, (광고)
s = c.get("/outreach/settings").text
assert "기본 문구(아직 저장 안 함)" in s and "주방의 본질을 지키며" in s and "정보통신망법" in s
r = c.post("/outreach/settings", data={"subject": "{이름}님 제안", "body": "안녕하세요 {이름}님", "sender_name": "미라네주방",
"footer": "수신 거부: 회신", "ad_label": "1"})
assert r.status_code == 303 and st.saved == "me@miras.co.kr" and st.t["ad_label"] is True
assert c.post("/outreach/settings", data={"subject": "", "body": "x"}).status_code == 400
# 붙여넣기 미리보기 → 추가
text = "kim@miras.co.kr, 김철수\\n@mira.kitchen 미라\\n홍길동\\n@nobody\\n"
p = c.post("/outreach/api/recipients/parse", json={"text": text}).json()["rows"]
assert [x["kind_label"] for x in p] == ["메일", "DM", "오류", "DM"], p
a = c.post("/outreach/api/recipients", json={"text": text}).json()
assert (a["added"], a["invalid"]) == (3, 1), a
p2 = c.post("/outreach/api/recipients/parse", json={"text": "kim@miras.co.kr"}).json()["rows"]
assert p2[0]["exists"] is True
rows = c.get("/outreach/api/recipients").json()["rows"]
kim, mira, nobody = rows
assert mira["dm_link"] == "https://ig.me/m/mira.kitchen" and "안녕하세요 미라님" in mira["dm_text"]
assert nobody["needs_name"] is True and kim["needs_name"] is False
# 미리보기 — 제목 (광고)·이름
pv = c.get(f"/outreach/api/recipients/{kim['id']}/preview").json()
assert pv["subject"] == "(광고) 김철수님 제안" and "안녕하세요 김철수님" in pv["html"] and "수신 거부: 회신" in pv["text"]
# 이름 고치기
assert c.put(f"/outreach/api/recipients/{nobody['id']}", json={"name": "노바디"}).json()["row"]["needs_name"] is False
# 메일 보내기 — Gmail 없음 = 409(재연결 안내)
r = c.post("/outreach/api/send", json={"ids": [kim["id"]]})
assert r.status_code == 409 and r.json()["reconnect"] is True
# DM 보냄 — 인스타 줄만
assert c.post(f"/outreach/api/recipients/{kim['id']}/dm-sent").status_code == 400
assert c.post(f"/outreach/api/recipients/{mira['id']}/dm-sent").json()["row"]["status"] == "보냄"
print("OK1")
run(body)
def body2(c):
who["u"] = me
kim = st.rows[0]
r = c.post("/outreach/api/send", json={"ids": [r["id"] for r in st.rows]})
assert r.status_code == 202 and r.json()["queued"] == 1, r.text # 메일 줄만(DM 은 빠짐)
assert batches == [[kim["id"]]], batches
assert c.post("/outreach/api/send", json={"ids": [kim["id"]]}).status_code == 409 # 이미 발송중 — 두 번 안 보냄
assert c.post("/outreach/api/send", json={"ids": []}).status_code == 400
assert "보내는 메일: <b>me@miras.co.kr</b>" in c.get("/outreach/").text
assert c.post("/outreach/api/recipients/delete", json={"ids": [st.rows[1]["id"]]}).json()["deleted"] == 1
print("OK2")
run(body2, connected=True)
''')
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK2", res.stdout)
def test_gmail_callback_outreach_origin(self):
"""안내문 발송에서 시작한 Gmail 연결 — 입출고 콜백이 outreach 권한으로 처리하고 안내문 화면으로."""
res = _run('''
from app.modules.inout import gmail
from starlette.requests import Request
class Inout2(Inout):
saved = []
def save_gmail_token(self, email, refresh_token_enc, scopes): self.saved.append(email)
class Client:
async def authorize_access_token(self, request):
return {"userinfo": {"email": "me@miras.co.kr"}, "scope": "openid email " + gmail.GMAIL_SCOPE, "refresh_token": "R"}
@main.app.get("/__mark")
def mark(request: Request):
request.session["_gmail_origin"] = "outreach"; request.session["_gmail_next"] = "/outreach/"; return {}
def body(c):
inout = Inout2(False)
main.app.state.inout_store = inout
who["u"] = me
with patch.object(gmail, "oauth_client", return_value=Client()), patch.object(gmail, "encrypt_token", return_value="enc"):
c.get("/__mark")
r = c.get("/inout/gmail/callback")
assert r.status_code == 303 and r.headers["location"].startswith("/outreach/?msg="), (r.status_code, r.headers.get("location"))
assert inout.saved == ["me@miras.co.kr"]
who["u"] = other # 안내문 권한 없으면 거절
c.get("/__mark")
assert c.get("/inout/gmail/callback").status_code == 403
print("OK")
run(body)
''')
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
@unittest.skipUnless(DB_ENABLED, "OUTREACH_TEST_DB_URL(localhost) 미설정")
class OutreachDBTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
from app.modules.outreach.db import OutreachDBStore
cls.st = OutreachDBStore(DSN)
@classmethod
def tearDownClass(cls):
cls.st.close()
def test_recipients_claim_finish_logs(self):
import threading
st = self.st
tag = uuid.uuid4().hex[:6]
res = st.add_recipients([{"address": f"Kim{tag}@miras.co.kr", "name": "김"}, {"address": f"@mira{tag}", "name": ""},
{"address": "홍길동", "name": "x"}, {"address": f"kim{tag}@MIRAS.co.kr", "name": "다른 이름"}], by="me@x.com")
self.assertEqual(res, {"added": 2, "existed": 1, "invalid": 1})
rows = {r["handle"]: r for r in st.list_recipients() if tag in r["handle"]}
kim, mira = rows[f"kim{tag}@miras.co.kr"], rows[f"mira{tag}"]
self.assertEqual((kim["kind"], kim["name"], mira["kind"]), ("email", "김", "instagram")) # 이미 있는 이름은 그대로
st.add_recipients([{"address": f"@mira{tag}", "name": "미라"}], by="me@x.com") # 빈 이름은 채움
self.assertEqual(st.get_recipient(mira["id"])["name"], "미라")
# 동시에 두 번 잡아도 한 번만
got = []
ts = [threading.Thread(target=lambda: got.append(st.claim_for_send([kim["id"], mira["id"]]))) for _ in range(4)]
[t.start() for t in ts]
[t.join() for t in ts]
self.assertEqual(sorted(len(g) for g in got), [0, 0, 0, 1])
self.assertEqual(st.get_recipient(kim["id"])["status"], "발송중")
self.assertEqual(st.delete_recipients([kim["id"]]), 0) # 보내는 중엔 못 지움
st.finish_send(kim["id"], ok=False, via="gmail", by="me@x.com", subject="제목", error="오류")
self.assertEqual((st.get_recipient(kim["id"])["status"], st.get_recipient(kim["id"])["last_error"]), ("실패", "오류"))
self.assertEqual(len(st.claim_for_send([kim["id"]])), 1) # 실패는 다시 잡힘
st.finish_send(kim["id"], ok=True, via="gmail", by="me@x.com", subject="제목")
k = st.get_recipient(kim["id"])
self.assertEqual((k["status"], k["sent_via"], k["last_error"], bool(k["sent_at"])), ("보냄", "gmail", "", True))
self.assertEqual(st.claim_for_send([kim["id"]]), []) # 보낸 줄은 안 잡힘
self.assertEqual(st.mark_dm_sent(mira["id"], by="me@x.com", subject="s")["status"], "보냄")
with self.assertRaises(ValueError):
st.mark_dm_sent(kim["id"], by="me@x.com", subject="s")
logs = [l for l in st.list_logs() if tag in l["address"].lower()]
self.assertEqual(sorted((l["kind"], l["ok"]) for l in logs), [("email", False), ("email", True), ("instagram", True)])
self.assertEqual(st.update_recipient(kim["id"], status="대기")["status"], "대기")
with self.assertRaises(ValueError):
st.update_recipient(kim["id"], status="보냄")
# 서버가 보내던 중 멈춘 줄 → 실패
st.claim_for_send([kim["id"]])
self.assertGreaterEqual(st.release_stuck(), 1)
self.assertEqual(st.get_recipient(kim["id"])["status"], "실패")
self.assertEqual(st.delete_recipients([kim["id"], mira["id"]]), 2)
def test_template_and_images(self):
st = self.st
t = st.get_template()
self.assertTrue(t["subject"])
saved = st.save_template({"subject": "제목 {이름}", "body": "본문", "ad_label": True, "sender_name": "미라네"}, by="Me@X.com")
self.assertEqual((saved["subject"], saved["ad_label"], saved["updated_by"], saved["is_default"]), ("제목 {이름}", True, "me@x.com", False))
with self.assertRaises(ValueError):
st.save_template({"subject": "", "body": "x"}, by="me")
ids = [st.add_image(filename=f"{i}.jpg", data=b"\xff\xd8" + bytes([i]), width=10, height=10, by="me") for i in range(2)]
try:
self.assertEqual([im["id"] for im in st.list_images() if im["id"] in ids], ids)
st.move_image(ids[1], -1)
self.assertEqual([im["id"] for im in st.list_images() if im["id"] in ids], [ids[1], ids[0]])
self.assertEqual(bytes(st.get_image(ids[0])["data"]), b"\xff\xd8\x00")
self.assertEqual(st.list_images(with_data=True)[0].keys() >= {"data"}, True)
finally:
for i in ids:
st.delete_image(i)
st.save_template(dict(store.DEFAULT_TEMPLATE), by="me")
if __name__ == "__main__":
unittest.main()