# -*- coding: utf-8 -*- """590-1 예정노선 설계 내용 = 프로젝트 폴더 한 파일(요구 452 · 453) — 지킴 시험. - 옮김 = 옛 DB 칸(지점 points · starts/ends · start/end · 빈 칸 = 연도 행 접기 · 노선 정본 · 옛 연도 노선) → 새 꼴 한 벌(좌표계 머리 한 곳 · 빈 연도 없음) - 원자 쓰기 = 바꿔치기 실패에도 옛 파일 그대로 · 임시 파일 안 남음 · 새 판 파일 거절 - 연도 읽기 = 업체 줄 연도는 파일 조각에서(낡은 DB 연도 무시 · ⑤) · 확정 = 지문 같을 때만 - 잠금 = 같은 프로젝트 [저장] 둘이 겹치지 않음 ./venv/Scripts/python.exe -m pytest resources/tester/test_590_1_plan_file.py -q """ from __future__ import annotations import asyncio import json import sys from pathlib import Path import pytest from fastapi import HTTPException sys.path.insert(0, str(Path(__file__).parent)) from helper_plan_file import use_plan, year_line_plan # noqa: E402 from common_util.common_util_crs import lonlat_to_tm # noqa: E402 from D03_PlanAnalysis import D03_PlanAnalysis_Network as net # noqa: E402 from D03_PlanAnalysis import D03_PlanAnalysis_Store as store # noqa: E402 from D04_PlanConfirm import D04_PlanConfirm_Router as d04 # noqa: E402 PID = "12953f5a-5ba1-42ad-a427-8ac857a58bc2" A = {"x": 210000.0, "y": 380000.0} B = {"x": 210300.0, "y": 380400.0} NETWORK = { "epsg": 5186, "lines": [{"id": "main", "vertices": [[0.0, 0.0], [100.0, 0.0]], "branch": None}], "marks": [{"line": "main", "at_m": 40.0}], "pieces": [ {"id": "p1", "line": "main", "from_m": 0.0, "to_m": 40.0, "year": 2027}, {"id": "p2", "line": "main", "from_m": 40.0, "to_m": 100.0, "year": 2029}, ], } # --- 옮김 --- @pytest.mark.parametrize( "base", [ {"epsg": 5186, "points": [A, B]}, {"epsg": 5186, "starts": [A], "ends": [B]}, {"epsg": 5186, "start": A, "end": B}, ], ) def test_migrate_old_point_forms(base): plan = store.migrate(json.dumps(base), json.dumps(NETWORK), []) assert plan["points"] == [A, B] and plan["epsg"] == 5186 assert plan["lines"] == NETWORK["lines"] and plan["pieces"] == NETWORK["pieces"] assert set(plan) == {"version", "epsg", "points", "lines", "marks", "pieces"} def test_migrate_folds_year_rows_and_legacy_route(): rows = [ {"year": 2027, "epsg": 5186, "route_json": None, "start_x": 1.0, "start_y": 2.0, "end_x": 3.0, "end_y": 4.0}, {"year": 2026, "epsg": 5186, "route_json": json.dumps({"planned": [[0, 0], [30, 40]]}), "start_x": 0.0, "start_y": 0.0, "end_x": 1.0, "end_y": 2.0}, {"year": 2028, "epsg": None, "route_json": None, "start_x": None, "start_y": None, "end_x": None, "end_y": None}, # 빈 연도 줄 ] # fmt: skip plan = store.migrate(None, None, rows) assert plan["points"] == [{"x": 0.0, "y": 0.0}, {"x": 3.0, "y": 4.0}] # 첫 시점 · 끝 종점 assert [p["year"] for p in plan["pieces"]] == [2026] # 빈 연도는 조각이 아님 assert store.plan_units(plan)[0]["length_m"] == 50.0 assert store.migrate(None, None, []) == store.empty_plan() def test_migrate_one_epsg_converts_points(): lon_lat = (127.1, 37.5) x, y = lonlat_to_tm(*lon_lat, 5185) plan = store.migrate( json.dumps({"epsg": 5185, "points": [{"x": x, "y": y}]}), json.dumps(NETWORK), [] ) assert plan["epsg"] == 5186 assert (plan["points"][0]["x"], plan["points"][0]["y"]) == pytest.approx( lonlat_to_tm(*lon_lat, 5186), abs=1e-3 ) # --- 원자 쓰기 · 판 --- def test_atomic_write_keeps_old_file_on_failure(tmp_path, monkeypatch): plan = {**store.empty_plan(5186), **NETWORK} store.save_plan(tmp_path, plan) path = store.plan_path(tmp_path) assert ( path.parent.name == "D03_PlanAnalysis" and json.loads(path.read_text("utf-8"))["version"] == 1 ) assert store.read_plan(tmp_path) == plan import common_util.common_util_json as cj def broken(source, target): raise PermissionError("잡힘") monkeypatch.setattr(cj, "replace_with_retry", broken) with pytest.raises(PermissionError): store.save_plan(tmp_path, {**plan, "lines": [], "marks": [], "pieces": []}) assert store.read_plan(tmp_path) == plan # 옛 파일 그대로 assert [p.name for p in path.parent.iterdir()] == ["plan_network.json"] # 임시 파일 안 남음 def test_newer_version_refused(tmp_path): path = store.plan_path(tmp_path) path.parent.mkdir(parents=True) path.write_text(json.dumps({**store.empty_plan(), "version": 2}), "utf-8") with pytest.raises(HTTPException) as err: store.read_plan(tmp_path) assert err.value.status_code == 409 assert store.read_plan(tmp_path / "없음") is None # --- 연도 읽기(⑤) --- def test_assignee_year_comes_from_file(monkeypatch): use_plan(monkeypatch, {**store.empty_plan(5186), **NETWORK}) _, units = asyncio.run(d04._units(PID)) stale = [{"id": 27, "piece_id": "p1", "year": 2028}, {"id": 28, "piece_id": "p2", "year": 2027}] assert [a["year"] for a in d04.with_years(stale, units)] == [2027, 2029] assert d04.with_years([{"id": 1, "piece_id": "없음", "year": 2027}], units)[0]["year"] is None def test_confirmed_only_when_fingerprint_matches(monkeypatch): plan = year_line_plan({2026: [[0.0, 0.0], [10.0, 0.0]], 2027: [[10.0, 0.0], [10.0, 10.0]]}) state = use_plan(monkeypatch, plan, {2026: "x"}) years = asyncio.run(store.plan_state(PID))["years"] assert years[2026]["confirmed_at"] == "x" and years[2027]["confirmed_at"] is None moved = json.loads(json.dumps(plan)) moved["lines"][0]["vertices"][0] = [20.0, 0.0] # 2026 조각 모양 바뀜(길이 같음) async def stale(_pid): # DB 지문 = 옛 파일 것 return {2026: {"fingerprint": years[2026]["fingerprint"], "confirmed_at": "x"}} monkeypatch.setattr(store, "year_status", stale) state["plan"] = moved assert asyncio.run(store.plan_state(PID))["years"][2026]["confirmed_at"] is None # --- 잠금 --- def test_two_saves_do_not_interleave(monkeypatch, tmp_path): order: list[str] = [] async def load(_pid): return tmp_path, store.read_plan(tmp_path) or store.empty_plan() async def year_start(_pid): return 2026 async def slow_status(connection, project_id, pieces, years): order.append(f"start {len(pieces)}") await asyncio.sleep(0.05) order.append(f"end {len(pieces)}") class Conn: async def __aenter__(self): return self async def __aexit__(self, *a): return False async def begin(self): pass async def commit(self): pass async def rollback(self): pass class Pool: def acquire(self): return Conn() monkeypatch.setattr(store, "load_plan", load) monkeypatch.setattr(net, "_year_start", year_start) monkeypatch.setattr(net, "_store_status", slow_status) monkeypatch.setattr(net, "get_db_pool", lambda: Pool()) forest = {"role": "SYSTEM_ADMIN", "email": "a@b.kr"} one = net.Network(**{**NETWORK, "pieces": NETWORK["pieces"][:1]}) two = net.Network(**NETWORK) async def both(): from uuid import UUID await asyncio.gather( net.put_plan_network(UUID(PID), one, forest), net.put_plan_network(UUID(PID), two, forest), ) asyncio.run(both()) assert order == ["start 1", "end 1", "start 2", "end 2"] assert len(store.read_plan(tmp_path)["pieces"]) == 2 # 뒤 저장이 이김 · 반쪽 없음