"""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()