9528f735b8
- Target and result cells accept text such as "20개". Values that parse
as amounts still go to the integer columns; anything else goes to the
new target_text/result_text columns (migration 021).
- Fix: PUT /api/goals/meeting-items/{id} dropped result_note, so the
last-week result text was never saved.
- Update meeting nav test to the month-bounded week numbering.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
276 lines
15 KiB
Python
276 lines
15 KiB
Python
"""회의록 실제 저장소/API의 권한·충돌·롤백·병합 글 보존을 DB 연결 없이 검증한다."""
|
|
import copy
|
|
import importlib
|
|
import json
|
|
import unittest
|
|
from contextlib import contextmanager
|
|
from datetime import date
|
|
from types import SimpleNamespace
|
|
from unittest.mock import patch
|
|
|
|
from fastapi import FastAPI
|
|
from fastapi.testclient import TestClient
|
|
|
|
from app.modules.project import store
|
|
from app.modules.project.db import ProjectStore
|
|
|
|
api = importlib.import_module("app.modules.project.router")
|
|
|
|
|
|
class Result:
|
|
def __init__(self, rows=()):
|
|
self.rows = list(rows)
|
|
|
|
def fetchone(self):
|
|
return self.rows[0] if self.rows else None
|
|
|
|
def fetchall(self):
|
|
return self.rows
|
|
|
|
|
|
class Connection:
|
|
def __init__(self):
|
|
self.rows = {}
|
|
for n in range(1, 5):
|
|
self.rows[n] = dict(id=n, week_start=date(2026, 9, 28), section="상품" if n < 4 else "유통",
|
|
section_color="", label=f"줄{n}", content="원본" if n == 1 else "대상" if n == 2 else "",
|
|
content_row_span=1, target_amount=100 * n, result_amount=None, status="",
|
|
marketplace_code="", carry_from=None, sort_order=n)
|
|
self.calls, self.depth, self.locked = [], 0, False
|
|
self.writes, self.fail_write, self.rollbacks = 0, None, 0
|
|
|
|
@contextmanager
|
|
def transaction(self):
|
|
before = copy.deepcopy(self.rows)
|
|
self.depth += 1
|
|
try:
|
|
yield
|
|
except Exception:
|
|
self.rows = before
|
|
self.rollbacks += 1
|
|
raise
|
|
finally:
|
|
self.depth -= 1
|
|
self.locked = False
|
|
|
|
def execute(self, sql, params):
|
|
self.calls.append((sql, params))
|
|
if sql == "SELECT week_start FROM goal_meeting_items WHERE id = %s":
|
|
return Result([copy.deepcopy(self.rows[params[0]])] if params[0] in self.rows else [])
|
|
if sql.startswith("SELECT week_start FROM goal_meetings"):
|
|
assert self.depth > 0
|
|
self.locked = True
|
|
return Result([{"week_start": params[0]}])
|
|
if sql.startswith("SELECT id, week_start") and "FROM goal_meeting_items" in sql:
|
|
return Result(copy.deepcopy(r) for r in self.rows.values() if r["week_start"] == params[0])
|
|
if sql.startswith("UPDATE goal_meeting_items SET"):
|
|
assert self.locked and self.depth > 0, "Every cell write must hold the meeting lock until commit"
|
|
self.writes += 1
|
|
if self.writes == self.fail_write:
|
|
raise RuntimeError("second write failed")
|
|
item = self.rows[params[-1]]
|
|
if "content_row_span = 1," in sql:
|
|
item["content_row_span"] = 1
|
|
keys = [s.strip().split(" = ")[0] for s in sql.split(" SET ")[1].split(" WHERE ")[0].split(",") if "%s" in s]
|
|
item.update(zip(keys, params[:-1]))
|
|
return Result([copy.deepcopy(item)])
|
|
raise AssertionError(sql)
|
|
|
|
|
|
class MeetingCellTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.conn = Connection()
|
|
|
|
@contextmanager
|
|
def connection():
|
|
yield self.conn
|
|
|
|
self.st = ProjectStore.__new__(ProjectStore)
|
|
self.st._pool = SimpleNamespace(connection=connection)
|
|
self.st._table_exists = lambda conn, name: True
|
|
self.st._column_exists = lambda conn, table, col: col == "content_row_span"
|
|
self.payload = dict(source_item=1, target_item=2, source_body="원본", target_body="대상", updated_by="ADMIN@TEST.LOCAL")
|
|
|
|
def test_atomic_move_preserves_rich_text_and_numeric_values(self):
|
|
rich = store.validate_goal_text(store.GOAL_RICH_PREFIX + json.dumps([
|
|
dict(text="서식", bold=True, italic=True, underline=True, color="#dc2626", size=24)]))
|
|
self.conn.rows[1]["content"] = rich
|
|
self.assertEqual(self.st.move_meeting_cell(**(self.payload | {"source_body": rich})), rich)
|
|
self.assertEqual(self.conn.rows[1]["content"], "")
|
|
self.assertEqual(self.conn.rows[2]["content"], rich)
|
|
self.assertEqual(self.conn.rows[2]["target_amount"], 200)
|
|
self.assertEqual(self.conn.rows[2]["updated_by"], "admin@test.local")
|
|
self.assertEqual(self.st.move_meeting_cell(**(self.payload | {"source_body": rich})), rich)
|
|
self.assertEqual(self.conn.writes, 2, "Lost-response retry must not rewrite cells")
|
|
|
|
def test_second_write_failure_rolls_back_both_cells(self):
|
|
before = copy.deepcopy(self.conn.rows)
|
|
self.conn.fail_write = 2
|
|
with self.assertRaises(RuntimeError):
|
|
self.st.move_meeting_cell(**self.payload)
|
|
self.assertEqual(self.conn.rows, before)
|
|
self.assertEqual(self.conn.rollbacks, 1)
|
|
|
|
def test_equivalent_rich_runs_match_editor_and_empty_move_is_rejected(self):
|
|
rich = store.GOAL_RICH_PREFIX + json.dumps([dict(text="원", bold=True), dict(text="본", bold=True)])
|
|
expected = store.validate_meeting_content(rich)
|
|
self.conn.rows[1]["content"] = rich
|
|
self.assertEqual(self.st.move_meeting_cell(**(self.payload | {"source_body": expected})), expected)
|
|
self.assertEqual(self.conn.rows[2]["content"], expected)
|
|
before = copy.deepcopy(self.conn.rows)
|
|
with self.assertRaises(ValueError):
|
|
self.st.move_meeting_cell(**(self.payload | {"source_body": ""}))
|
|
self.assertEqual(self.conn.rows, before)
|
|
|
|
def test_stale_source_or_target_never_overwrites(self):
|
|
for item in (1, 2):
|
|
with self.subTest(item=item):
|
|
self.setUp()
|
|
self.conn.rows[item]["content"] = "다른 창에서 변경"
|
|
before = copy.deepcopy(self.conn.rows)
|
|
with self.assertRaises(store.GoalCellConflict):
|
|
self.st.move_meeting_cell(**self.payload)
|
|
self.assertEqual(self.conn.rows, before)
|
|
|
|
def test_different_week_and_hidden_cells_cannot_be_written(self):
|
|
self.conn.rows[2]["week_start"] = date(2026, 9, 21)
|
|
with self.assertRaises(KeyError):
|
|
self.st.move_meeting_cell(**self.payload)
|
|
self.conn.rows[2]["week_start"] = date(2026, 9, 28)
|
|
self.conn.rows[1]["content_row_span"] = 2
|
|
with self.assertRaises(store.GoalCellConflict):
|
|
self.st.move_meeting_cell(**self.payload)
|
|
with self.assertRaises(store.GoalCellConflict):
|
|
self.st.update_meeting_item(item_id=2, fields={"content": "hidden"})
|
|
|
|
def test_merge_unmerge_preserves_all_text_and_formats(self):
|
|
self.conn.rows[1]["content"] = store.validate_goal_text(store.GOAL_RICH_PREFIX + json.dumps([dict(text="원본", bold=True)]))
|
|
out = self.st.merge_meeting_cells(item_from=1, item_to=3)
|
|
self.assertEqual(out["row_span"], 3)
|
|
self.assertEqual(store.goal_text_plain(out["body"]), "원본\n대상")
|
|
self.assertTrue(store.goal_text_runs(out["body"])[0]["bold"])
|
|
self.assertEqual([self.conn.rows[n]["content"] for n in (2, 3)], ["", ""])
|
|
self.st.unmerge_meeting_cell(item_id=1)
|
|
self.assertEqual(self.conn.rows[1]["content_row_span"], 1)
|
|
self.assertEqual(self.conn.rows[1]["content"], out["body"])
|
|
|
|
def test_merge_validation_and_rollback(self):
|
|
for endpoint in (1, 4):
|
|
with self.subTest(endpoint=endpoint), self.assertRaises(ValueError):
|
|
self.st.merge_meeting_cells(item_from=1, item_to=endpoint)
|
|
before = copy.deepcopy(self.conn.rows)
|
|
self.conn.fail_write = 2
|
|
with self.assertRaises(RuntimeError):
|
|
self.st.merge_meeting_cells(item_from=1, item_to=3)
|
|
self.assertEqual(self.conn.rows, before)
|
|
|
|
def test_existing_merge_must_be_selected_whole(self):
|
|
self.st.merge_meeting_cells(item_from=1, item_to=2)
|
|
with self.assertRaises(store.GoalCellConflict):
|
|
self.st.merge_meeting_cells(item_from=2, item_to=3)
|
|
self.assertEqual(self.st.merge_meeting_cells(item_from=1, item_to=3)["row_span"], 3)
|
|
|
|
def test_merged_rows_require_unmerge_before_delete_or_reorder(self):
|
|
self.st.merge_meeting_cells(item_from=1, item_to=2)
|
|
with self.assertRaises(ValueError):
|
|
self.st.delete_meeting_item(item_id=1)
|
|
with self.assertRaises(ValueError):
|
|
self.st.move_meeting_item(item_id=3, direction=-1)
|
|
|
|
def test_plain_and_rich_saves_share_move_lock_and_visible_length_limit(self):
|
|
rich = store.GOAL_RICH_PREFIX + json.dumps([dict(text="가", bold=True)] * 4000)
|
|
out = self.st.update_meeting_item(item_id=1, fields={"content": rich})
|
|
self.assertEqual(len(store.goal_text_plain(out["content"])), 4000)
|
|
with self.assertRaises(ValueError):
|
|
self.st.update_meeting_item(item_id=1, fields={"content": "가" * 4001})
|
|
safe = store.goal_text_html(store.validate_goal_text(store.GOAL_RICH_PREFIX + json.dumps([
|
|
dict(text="<script>alert(1)</script>", color="red;display:none", size=200)])))
|
|
self.assertNotIn("<script>", safe)
|
|
self.assertNotIn("display:none", safe)
|
|
|
|
def test_http_permissions_conflict_validation_and_migration(self):
|
|
app = FastAPI()
|
|
app.include_router(api.router)
|
|
app.state.project_store = self.st
|
|
client = TestClient(app)
|
|
endpoints = [("POST", "/meeting-cells/move", self.payload),
|
|
("POST", "/meeting-cells/merge", dict(item_from=1, item_to=2)),
|
|
("DELETE", "/meeting-items/1/cell-merge", None)]
|
|
with patch.object(api, "_require_user", return_value=dict(role="user", email="user@test.local")):
|
|
for method, endpoint, body in endpoints:
|
|
self.assertEqual(client.request(method, "/project/api/goals" + endpoint, json=body).status_code, 403)
|
|
with patch.object(api, "_require_user", return_value=dict(role="admin", email="admin@test.local")):
|
|
url = "/project/api/goals/meeting-cells/move"
|
|
self.assertEqual(client.post(url, json={}).status_code, 400)
|
|
self.assertEqual(client.post(url, json=self.payload | {"source_body": None}).status_code, 400)
|
|
self.assertEqual(client.post(url, json=self.payload | {"target_body": "changed"}).status_code, 409)
|
|
self.st._meeting_cells = lambda conn: False
|
|
self.assertEqual(client.post("/project/api/goals/meeting-cells/merge", json=dict(item_from=1, item_to=2)).status_code, 503)
|
|
self.assertEqual(client.post(url, json=self.payload).status_code, 200, "Move/formatting work without 019")
|
|
|
|
def test_amount_cells_accept_text_after_021_and_result_note_reaches_store(self):
|
|
"""정량 목표·결과 — 숫자면 원 정수 칸, 글(예: 20개)이면 글 칸(021). 지난주 결과 글(result_note, 020)은 API 를 거쳐 저장된다."""
|
|
self.st._column_exists = lambda conn, table, col: col in {"content_row_span", "result_note", "target_text"}
|
|
for r in self.conn.rows.values():
|
|
r.update(result_note="", target_text="", result_text="")
|
|
out = self.st.update_meeting_item(item_id=1, fields={"target_amount": "20개", "result_amount": "120만"})
|
|
self.assertEqual((out["target_amount"], out["target_text"]), (None, "20개"))
|
|
self.assertEqual((out["result_amount"], out["result_text"]), (1_200_000, ""))
|
|
out = self.st.update_meeting_item(item_id=1, fields={"target_amount": "1,000"})
|
|
self.assertEqual((out["target_amount"], out["target_text"]), (1000, ""), "숫자로 바꾸면 글은 지운다")
|
|
with self.assertRaises(ValueError):
|
|
self.st.update_meeting_item(item_id=1, fields={"target_amount": "가" * 101})
|
|
app = FastAPI()
|
|
app.include_router(api.router)
|
|
app.state.project_store = self.st
|
|
client = TestClient(app)
|
|
with patch.object(api, "_require_user", return_value=dict(role="admin", email="admin@test.local")):
|
|
r = client.put("/project/api/goals/meeting-items/2", json={"result_note": "잘함", "result_amount": "3박스"})
|
|
self.assertEqual(r.status_code, 200, r.text)
|
|
self.assertEqual(self.conn.rows[2]["result_note"], "잘함")
|
|
self.assertEqual((self.conn.rows[2]["result_amount"], self.conn.rows[2]["result_text"]), (None, "3박스"))
|
|
# 021 전 — 글은 예전처럼 숫자 오류(400), 숫자는 그대로 저장
|
|
for k in ("_meeting_v21_ok", "_meeting_v20_ok"):
|
|
self.st.__dict__.pop(k, None)
|
|
self.st._column_exists = lambda conn, table, col: col == "content_row_span"
|
|
with self.assertRaises(ValueError):
|
|
self.st.update_meeting_item(item_id=3, fields={"target_amount": "20개"})
|
|
self.assertEqual(self.st.update_meeting_item(item_id=3, fields={"target_amount": "5"})["target_amount"], 5)
|
|
|
|
def test_rendered_meeting_keeps_merge_geometry_and_escapes_rich_text(self):
|
|
from pathlib import Path
|
|
from jinja2 import ChoiceLoader, DictLoader, Environment, FileSystemLoader
|
|
|
|
root = Path(__file__).resolve().parents[1]
|
|
rich = store.validate_goal_text(store.GOAL_RICH_PREFIX + json.dumps([
|
|
dict(text="<img onerror=alert(1)>\n계획", bold=True, size=24, color="#dc2626")]))
|
|
self.conn.rows[1]["content"] = rich
|
|
self.st.merge_meeting_cells(item_from=1, item_to=2)
|
|
items = [self.st._meeting_item(copy.deepcopy(r)) | {"prev": None} for r in self.conn.rows.values()]
|
|
head = dict(week_start="2026-09-28", notes="", attendees="", week_target=None,
|
|
items=items, prev_meeting=None, cell_merges=True)
|
|
fake = SimpleNamespace(get_meeting=lambda **kw: copy.deepcopy(head),
|
|
goal_month_targets=lambda **kw: dict(sales_unit="원", sales_target=None, roas_target=None))
|
|
request = SimpleNamespace(app=SimpleNamespace(state=SimpleNamespace(performance_store=None)))
|
|
view = api._meeting_view(request, fake, year=2026, month=9, week=date(2026, 9, 28))
|
|
rows = view["meeting"]["sections"][0]["rows"]
|
|
self.assertEqual(rows[0]["content_span"], 2)
|
|
self.assertTrue(rows[1]["content_hidden"])
|
|
env = Environment(loader=ChoiceLoader([
|
|
DictLoader({"erp_base.html": "{% block head_extra %}{% endblock %}{% block content %}{% endblock %}"}),
|
|
FileSystemLoader(root / "app/modules/project/templates")]), autoescape=True)
|
|
html = env.get_template("project/goal_meeting.html").render(
|
|
user=dict(email="test@local"), is_admin=True, goal_year=2026, goal_month=9,
|
|
meetings_enabled=True, week="2026-09-28", week_end="2026-10-04", prev_week="2026-09-21",
|
|
prev_week_end="2026-09-27", meeting_status=store.MEETING_STATUS, pj_kr_holidays={},
|
|
nav_projects=[], goal_years=[2026], color_palette=[], project_icons=[], meet_members=[], month_plan=None, **view)
|
|
self.assertIn('rowspan="2" data-meet-item="1"', html)
|
|
self.assertNotIn('data-meet-item="2"', html)
|
|
self.assertIn("<img onerror=alert(1)>", html)
|
|
self.assertNotIn("<img onerror=", html)
|
|
self.assertIn("font-weight:700", html)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|