Files
Aislo/resources/tester/test_m02_template_layers.py
T
eomsangdonandClaude Opus 5.5 102c993247 chore(853-2): 걸음 0 묶음 ④ — 한 번 쓰고 끝난 도구 걷음
- 파일: M02_Copy_Units · M02_Copy_Symbols · M02_Copy_Migrate · M02_Doc_Migrate · M02_Labor_Migrate · M02_Template_Migrate
- 조각: Labor_SkRow 옮기기(convert · relink · money · run_here · _sandbox · migrate · to_xlsx · __main__ 등 · 289 → 61 줄) · Library_Flat migrate · __main__ · _value
- 살아 있는 project_root(대시보드 요약)는 M02_Template_Layers 로 옮김 · B01_Dashboard_Summary 가져감 고침 · 지킴 시험 하나 더함
- 먼저 확인: 보기만 돌림 = Copy_Units · Copy_Symbols 채울것없음 6 · Copy_Migrate · Doc_Migrate 있음 6 · Labor_Migrate 옮김 0 · Labor_SkRow 0 줄 · Library_Flat 0 줄 — 다시 돌릴 일 없음 · 비시험에서 그 안 함수를 가져가는 곳 0
- 시험: 도구만 보던 795-3 · labor_migrate 파일 지움 · 함수째 지움(801-5 · 800-5 · 802-4b1 · 795-4 · 811-1 · 740-1 · template_layers) · 740-1 의 SC 값 셈 도우미는 시험 안으로
- 낡은 글자 시험: structures_summary_snapshot 의 robocopy 인자 글자 대조 지움(인자가 조건식으로 바뀌어 이미 실패 · 소스 글자 시험)
- 검증: 빌더 --check 같음 · 핵심 시험 99 통과 · 관련 시험 631 + 20 통과 · 서버 로그 오류 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 12:31:49 +09:00

295 lines
14 KiB
Python

"""M02 양식 층 — 자리 · 복사 · 초기화 · 회사 적용 · 가져오기 · 권한 (임시 storage)."""
from __future__ import annotations
import json
from pathlib import Path
from typing import Any
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from common_util import common_util_storage
from common_util.common_util_auth import verify_session
from config import config_system
from M02_MasterTemplete import M02_MasterTemplete_Router_Items as items_router
from M02_MasterTemplete import M02_MasterTemplete_Router_Layers as router_module
from M02_MasterTemplete import M02_Template_Layers as layers
from resources.tester.helper_m02_master_sample import sample_table
P1 = "11111111-1111-1111-1111-111111111111"
P2 = "22222222-2222-2222-2222-222222222222"
P_OTHER = "33333333-3333-3333-3333-333333333333"
@pytest.fixture
def world(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> dict[str, Any]:
storage = tmp_path / "storage"
storage.mkdir()
monkeypatch.setattr(config_system, "STORAGE_BASE_DIR", str(storage))
monkeypatch.setattr(common_util_storage, "STORAGE_BASE_DIR", str(storage))
monkeypatch.setattr(layers, "SYSTEM_ROOT", tmp_path / "master_template")
layers.write_template(layers.system_dir(), "table", "구조물집계표", {"판": 1, "열": []})
layers.write_template(layers.system_dir(), "drawing", "A1_도각", {"format": 6})
projects = {
P1: {"id": P1, "name": "첫째", "company_id": 7, "user_id": 42},
P2: {"id": P2, "name": "둘째", "company_id": 7, "user_id": 43},
P_OTHER: {"id": P_OTHER, "name": "남의 회사", "company_id": 9, "user_id": 90},
}
for row in projects.values():
row["storage_path"] = f"storage/{row['company_id']}/{row['user_id']}/{row['id']}"
root = Path(common_util_storage.resolve_stored_project_path(row["storage_path"]))
layers.seed_project(root)
users = {42: 7, 43: 7, 90: 9}
async def project_row(project_id: str) -> dict[str, Any] | None:
found = projects.get(str(project_id))
return dict(found) if found else None
async def company_users(company_id: int) -> list[dict[str, Any]]:
return [{"user_id": u, "name": f"u{u}"} for u, c in users.items() if c == company_id]
async def company_projects(company_id: int) -> list[dict[str, Any]]:
return [
{"project_id": p["id"], "name": p["name"], "storage_path": p["storage_path"]}
for p in projects.values()
if p["company_id"] == company_id
]
monkeypatch.setattr(router_module, "_project_row", project_row)
monkeypatch.setattr(router_module, "_company_users", company_users)
monkeypatch.setattr(router_module, "_company_projects", company_projects)
session = {"user_id": 42, "company_id": 7, "role": "USER", "is_master": False}
app = FastAPI()
app.include_router(router_module.router)
app.dependency_overrides[verify_session] = lambda: session
return {"client": TestClient(app), "session": session, "storage": storage}
def _root(world: dict[str, Any], project_id: str, company: int = 7, user: int = 42) -> Path:
return (world["storage"] / str(company) / str(user) / project_id).resolve()
def _url(project_id: str = P1) -> str:
return f"/api/m02/layers/project/templates/table/구조물집계표?project_id={project_id}"
def test_프로젝트_만들기_복사는_작업본과_초기본_둘에_manifest(world: dict[str, Any]) -> None:
root = _root(world, P1)
assert (root / "templates/table/구조물집계표.json").is_file()
assert (root / "templates/_initial/drawing/A1_도각.json").is_file()
entry = layers.read_manifest(root / "templates")["table/구조물집계표"]
assert entry["층"] == "system" and entry["판"] == layers.version_of(
layers.system_dir() / "table/구조물집계표.json"
)
def test_옛_프로젝트_넣기는_더하기만(world: dict[str, Any]) -> None:
root = _root(world, P1)
layers.write_template(root / "templates", "table", "구조물집계표", {"고침": True})
assert layers.seed_project(root, only_missing=True) == {"작업본": [], "초기": []}
assert layers.read_template(root / "templates", "table", "구조물집계표")["문서"] == {
"고침": True
}
def test_작업본_저장_판_다르면_409_초기화는_초기본으로(world: dict[str, Any]) -> None:
client = world["client"]
got = client.get(_url()).json()
assert got["층"] == "project" and got["문서"]["판"] == 1
saved = client.put(_url(), json={"판": got["판"], "문서": {"판": 2, "열": []}})
assert saved.status_code == 200
stale = client.put(_url(), json={"판": got["판"], "문서": {"판": 3, "열": []}})
assert stale.status_code == 409
assert "table/구조물집계표" in layers.reset_project(_root(world, P1)) # [초기화] = B07 길
assert client.get(_url()).json()["문서"] == {"판": 1, "열": []}
initial = _root(world, P1) / "templates/_initial/table/구조물집계표.json"
assert layers.read_template(initial.parent.parent, "table", "구조물집계표")["문서"]["판"] == 1
def test_개인_양식은_본인만_쓰고_같은_회사_관리자는_읽음(
world: dict[str, Any], monkeypatch: pytest.MonkeyPatch
) -> None:
client, session = world["client"], world["session"]
notes: list[str] = []
async def note(_session: dict[str, Any], got: Any) -> None:
notes.append(got.owner)
monkeypatch.setattr(items_router, "_note", note)
mine = f"/api/m02/layers/personal/templates/table/구조물집계표?project_id={P1}"
assert client.get(mine).status_code == 200
session.update(user_id=43)
theirs = mine + "&user_id=42"
# 층 길 = 권한 한 벌(PLAN 27-1c) — 같은 회사 남의 개인 층은 회사 관리자만(맡은 회사 · 39-6)
assert client.get(theirs).status_code == 403
session["role"] = "ADMIN"
assert client.get(theirs).status_code == 200
assert client.get(mine + "&owner=7/42").status_code == 200
put = client.put(
f"/api/m02/layers/personal/templates/table/내표?project_id={P1}&user_id=42",
json={"판": None, "문서": {"열": []}},
)
assert put.status_code == 200 # 회사 관리자 = 같은 회사 개인 고침 · 시스템 로그
assert (world["storage"] / "7/42/templates/table/내표.json").is_file()
assert notes == ["7/42"]
session["role"] = "USER"
# 첫 진입 때 구조물집계표 빈 뼈대가 서므로(PLAN 21-2) 새 이름으로 씀
put = client.put(
f"/api/m02/layers/personal/templates/table/내표?project_id={P1}",
json={"판": None, "문서": {"열": []}},
)
assert put.status_code == 200
assert (world["storage"] / "7/43/templates/table/내표.json").is_file()
session["role"] = "ADMIN"
assert client.get(mine.replace(P1, P_OTHER)).status_code == 403
def test_시스템_층은_읽기만_이름은_막음(world: dict[str, Any]) -> None:
client = world["client"]
assert client.get("/api/m02/layers/system/templates").json()["양식"]
put = client.put(
"/api/m02/layers/system/templates/table/구조물집계표", json={"판": None, "문서": {}}
)
assert put.status_code == 403
for name in ("..", "_initial", "a.b/c"):
with pytest.raises(ValueError):
layers.template_path(layers.system_dir(), "table", name)
def test_채운_표는_작업본을_채워_돌려주고_저장_안_함(
world: dict[str, Any], monkeypatch: pytest.MonkeyPatch
) -> None:
async def designs(project_id: str) -> list[dict[str, Any]]:
return [{"chainage_m": 40.0, "design": {"pipe_length_m": 12}}]
monkeypatch.setattr(router_module, "_cross_designs", designs)
monkeypatch.setattr(router_module.fill, "recalc", lambda document: {"계산": {}})
root = _root(world, P1)
layers.write_template(root / "templates", "table", "구조물집계표", sample_table())
edits = root / "B04_PreProcess/drainage/edits"
edits.mkdir(parents=True, exist_ok=True)
(edits / "pipe_points.json").write_text(
json.dumps({"points": [{"chainage_m": 40.0, "source": "user"}]}), encoding="utf-8"
)
before = layers.version_of(root / "templates/table/구조물집계표.json")
got = world["client"].get(f"/api/m02/projects/{P1}/tables/구조물집계표/filled").json()
# 프로젝트 채움 = 지정 항목 모드(PLAN 21-3) — 집계 항목 미지정 관은 표에 안 들어감
# 배관 한 개 = 관 · 보호공(유입) · 보호공(유출) 컨테이너 셋(54-1) → 미지정 4건
assert not any(r["id"] == "s40.00" for r in got["문서"]["줄"])
assert "집계 항목 미지정 4건 — 표에 안 들어감" in got["문서"]["알림"]
assert got["결과"] == {"계산": {}} and got["판"] == before
assert layers.version_of(root / "templates/table/구조물집계표.json") == before
def test_프로젝트_만들기_자리에서_시스템_양식을_복사(world: dict[str, Any], tmp_path: Path) -> None:
from B02_ProjRegister.B02_ProjRegister_Repository import _initialize_project_storage
layers.write_template(layers.company_dir(7), "table", "구조물집계표", {"회사": 1})
root = tmp_path / "new_project"
_initialize_project_storage(root, "new")
got = layers.read_template(root / "templates", "table", "구조물집계표")
assert got["문서"] == {"판": 1, "열": []} # 회사 공식이 있어도 시스템
assert (root / "templates/_initial/drawing/A1_도각.json").is_file()
assert (root / "project_manifest.json").is_file()
def test_프로젝트_표_저장은_서버가_설계값을_걸러_씀(world: dict[str, Any]) -> None:
from M02_MasterTemplete import M02_Table_Fill as fill
client = world["client"]
master = sample_table()
filled = fill.fill_document(
master,
[
{
"type_id": "position_sign",
"placement": "point",
"chainage_m": 40.0,
"start_m": None,
"end_m": None,
"options": {},
}
],
)
filled["줄"][1]["값"]["h_intake"] = 2
version = client.get(_url()).json()["판"]
assert client.put(_url(), json={"판": version, "문서": filled}).status_code == 200
stored = layers.read_template(_root(world, P1) / "templates", "table", "구조물집계표")["문서"]
assert stored["줄"][1] == {"id": "s40.00", "값": {"sta": "NO.2", "h_intake": 2}}
assert "알림" not in stored and all("|" not in c["id"] for c in stored["열"])
def test_뼈대_없는_문서는_400으로_거절하고_파일을_안_씀(world: dict[str, Any]) -> None:
client = world["client"]
path = _root(world, P1) / "templates/drawing/A1_도각.json"
before = path.read_bytes()
url = f"/api/m02/layers/project/templates/drawing/A1_도각?project_id={P1}"
version = layers.version_of(path)
for document in ({}, {"format": 6}, {"entities": {}}):
got = client.put(url, json={"판": version, "문서": document})
assert got.status_code == 400 and "entities" in got.json()["detail"]
assert path.read_bytes() == before
table = _url()
assert client.put(table, json={"판": None, "문서": {}}).status_code == 400
assert client.put(url, json={"판": version, "문서": {"entities": []}}).status_code == 200
def _mine(name: str = "내양식", layer: str = "personal") -> str:
return f"/api/m02/layers/{layer}/templates/table/{name}?project_id={P1}"
def test_개인_회사_양식_지우기_권한_판_이름_예외(world: dict[str, Any]) -> None:
client, session = world["client"], world["session"]
doc = {"열": []}
for layer in ("personal", "company"):
client.put(_mine(layer=layer), json={"판": None, "문서": doc})
personal = layers.personal_dir(7, 42) / "table/내양식.json"
company = layers.company_dir(7) / "table/내양식.json"
assert personal.is_file() and not company.is_file() # 일반 사용자 회사 저장은 403
version = layers.version_of(personal)
# 시스템 · 프로젝트 층은 거절
for layer in ("system", "project"):
assert client.delete(_mine("구조물집계표", layer) + f"&판={version}").status_code == 403
assert (_root(world, P1) / "templates/table/구조물집계표.json").is_file()
# 이름 예외 · 판 없음 · 판 다름 · 없는 양식
for bad in ("%2E%2E", "a%2E%2Eb", "a%2Fb", "a%5Cb", "_initial", ".x", "a*b"):
got = client.delete(_mine(bad) + f"&판={version}")
assert got.status_code in (400, 404) and personal.is_file(), bad
assert client.delete(_mine("a%2Fb") + f"&판={version}").status_code in (400, 404)
assert client.delete(_mine()).status_code == 400
stale = client.delete(_mine() + "&판=0000000000000000")
assert stale.status_code == 409 and stale.json()["detail"]["판"] == version
assert client.delete(_mine("없는것") + f"&판={version}").status_code == 404
# 다른 회사 사람은 못 지움 · 회사 층은 관리자만
assert client.delete(_mine("내양식", "company") + f"&판={version}").status_code == 403
# 지움 · 연달아 누르면 둘째는 404 · manifest 줄도 없어짐
assert client.delete(_mine() + f"&판={version}").status_code == 200
assert not personal.exists()
assert client.delete(_mine() + f"&판={version}").status_code == 404
session["role"] = "ADMIN"
client.put(_mine(layer="company"), json={"판": None, "문서": doc})
assert company.is_file()
session.update(role="USER")
assert (
client.delete(_mine(layer="company") + f"&판={layers.version_of(company)}").status_code
== 403
)
session.update(role="ADMIN")
assert (
client.delete(_mine(layer="company") + f"&판={layers.version_of(company)}").status_code
== 200
)
assert "table/내양식" not in layers.read_manifest(layers.company_dir(7))
def test_저장_경로_실경로는_storage_안_있는_폴더만(world: dict[str, Any]) -> None:
"""대시보드 요약이 쓰는 `project_root` — 있는 폴더만 · 없음 · 밖 · `..` = None(만들지 않음)."""
assert layers.project_root(f"storage/7/42/{P1}") == _root(world, P1)
for bad in (None, "", "storage/7/42/없는것", "other/7/42", "storage/../7", "storage"):
assert layers.project_root(bad) is None, bad
assert not (world["storage"] / "7/42/없는것").exists()