refactor(855-E L3ⓐ): M01 기초 저장 · 검사 · 막힘 세기 = 수식 문서 기준 · 로직 줄 쓰기 = Store_Logic.mirror 한 자리
앞 세션 auto 커밋 cce57c298(Store_Logic 새 길 · /logic 답 머리만 · 판 = 문서 파일 지문 · 개정 = 문서 머리 대조 · 별칭 · 기계 등록 · [신규] · [삭제])에 이어 - Store_Cache: 막힘 세기(blocks · counted)를 문서 파일마다 · 저장 검사 logic_errors = 키 겹침 · 대장(요소 + 문서 키) · 연결 · 문서 막힘(check_logics 로직 줄 검사 걷음) · _docs_of = 문서 전부 · narrow 로직 갈래 걷음 · check_saved(부름 0) 지움 - Store_Save: 기초(로직 파일) 받지 않음(400) · gone · labor_errors(whole) 갈래 걷음 - Store_Logic: 정본 파일에도 새 기초(그 파일 표 키 — 옛 /save 와 같음) · 지움 검사에 조합 · 지운 기초를 부르던 문서 더함(옛 422 그대로) · 쓰는 곳 409 는 Doc.remove 로(옛 자리) - 시험(옛 /save 로 로직 줄 셈 칸 고침 · /logic 답 셈 칸을 붙든 것 = 죽은 길): 새 test_855_l3_doc_only(로직 파일 없음 + 같이 쓰기 끔 = 켬과 답 같음 · 목록 · 상세 · 저장 · 개정 409 · 판 409 · 별칭 · 신규 · 복사 · 삭제 · 기계 등록) · test_m01_cache 셈 칸 /save 검사 셋 · test_794_1 식 고침 /save 422 걷음(셈 칸 고침 = 문서 저장 몫 · /save 는 머리만 씀) · test_m01_make 「시험 계산에 돈다」 → 빈 문서로 열림 · test_m01_api · test_m01_text 옛 셈 길 시험은 로직 줄 사본에서 읽음 · test_854_2_m01_key_book 대장 끊김 = 인력 줄 + 기초 문서 쓰기 · test_794_1b · test_804_7 판 = 문서 파일 · test_802_3 문서 없는 키 = 404(빈 문서 안 지음) · test_826_2 좁힌 검사 = 판정만 견줌(기초 흠 글이 문서 꼴) · 로직 갈래 셋 뺌 · test_m01_copy 옛 시트 길 걷고 master_copy 왕복만 · test_854_2_m01_copy_doc 식 복사 → 기본정보 고친 복사 · test_713_1 · test_796_1 row_print 줄 뺌(row_print 지움) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -1,11 +1,9 @@
|
||||
"""713-1 지킴 — 로직 정본 줄 고침 · 지우기 · 더하기는 「원문 개정 반영」 확인(`개정확인`) 없이는 409 ·
|
||||
요소 · 같은 줄 다시 보냄은 그대로 · 줄 바탕 지문(`Store_Revise.row_print`). 임시 사본 폴더만 씀."""
|
||||
요소 · 같은 줄 다시 보냄은 그대로 · 대조 = 문서 머리(855 L3 ⓐ). 임시 사본 폴더만 씀."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import shutil
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from fastapi import FastAPI
|
||||
@@ -103,9 +101,6 @@ def test_요소_파일은_대상_밖(client: TestClient) -> None:
|
||||
assert client.post("/api/m01/save", json={"files": [part]}).status_code == 200
|
||||
|
||||
|
||||
def test_지문_수_꼴_같음() -> None:
|
||||
a = {"이름": "가", "호표": [{"수량": Decimal("10.0")}], "끝수": 1}
|
||||
b = {"이름": "나", "호표": [{"수량": 10}], "끝수": 1.0, "별칭": "x"}
|
||||
assert revise.row_print(a) == revise.row_print(b)
|
||||
def test_정본_파일_가름() -> None:
|
||||
assert revise.is_canon("로직_산림품셈_09장_토공.json")
|
||||
assert not revise.is_canon("로직_자체.json") and not revise.is_canon("인력.json")
|
||||
|
||||
@@ -1,14 +1,12 @@
|
||||
# ruff: noqa: E501
|
||||
"""794-1 M01 로직 줄 식 고침 저장 — `/save`(개정 확인) 뒤 다시 셈 · 틀린 식 422 · 시스템 관리자만.
|
||||
"""794-1 M01 저장 길 — 시스템 관리자만(로직 줄 식 고침 `/save` 시험은 855 L3 ⓐ 에서 걷음 — /save 는 기초 머리만 씀 · 셈 = 문서 저장).
|
||||
|
||||
- 시트 서버 길(`/logic/sheet` · `/check`)은 화면 0 이라 853-1 에 걷음 — 남은 것은 살아 있는 `/save` · `/calc`
|
||||
- 서버(사본 폴더): 공구손료 식 1 → 2 % 저장(개정 확인 409 → 200) 뒤 셈 51,802 · 틀린 식 저장 422 · 시스템 관리자가 아니면 403
|
||||
- 서버(사본 폴더): 시스템 관리자가 아니면 403
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import hashlib
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
|
||||
@@ -19,18 +17,8 @@ from fastapi.testclient import TestClient
|
||||
from common_util.common_util_auth import require_system_admin, verify_session
|
||||
from M01_MasterData import M01_MasterData_Router as m01_router
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
|
||||
|
||||
REAL = store.FOLDER
|
||||
KEY = "GC000211" # 합판거푸집 설치 및 해체
|
||||
INPUTS = {"자재지역": "포항", "유형": "보통", "사용횟수": "6회", "높이감률": 0, "지붕슬래브": "아님",
|
||||
"폼타이": "아님", "폼타이규격": "12.7㎜", "측압": "3t/㎡", "구멍땜": 0} # fmt: skip
|
||||
TOOL_1 = "(형틀목공 * LB000007 + 보통인부 * LB000002) * 1 / 100" # 덧줄 첫 줄 엔진 식
|
||||
TOOL_2 = TOOL_1.replace("* 1 / 100", "* 2 / 100")
|
||||
|
||||
|
||||
def _hashes(folder: Path) -> dict[str, str]:
|
||||
return {p.name: hashlib.md5(p.read_bytes()).hexdigest() for p in sorted(folder.glob("*.json"))}
|
||||
|
||||
|
||||
# ── 서버 ─────────────────────────────────────────────────────────────
|
||||
@@ -45,43 +33,6 @@ def folder(tmp_path: Path, monkeypatch) -> Path:
|
||||
return master
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client(folder: Path) -> TestClient:
|
||||
app = FastAPI()
|
||||
app.include_router(m01_router.router)
|
||||
app.include_router(old_engine.router)
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _post(client: TestClient, url: str, body: dict, want: int = 200) -> dict:
|
||||
res = client.post(url, json=body)
|
||||
assert res.status_code == want, res.text
|
||||
return res.json()
|
||||
|
||||
|
||||
def test_저장_길_개정_확인_다시_셈_틀린_식_422(client: TestClient, folder: Path) -> None:
|
||||
real = _hashes(REAL)
|
||||
one = client.get("/api/m01/logic", params={"key": KEY}).json()
|
||||
row = copy.deepcopy(one["logic"])
|
||||
assert row["덧줄"][0]["식"] == TOOL_1
|
||||
row["덧줄"][0]["식"] = TOOL_2
|
||||
body = {"files": [{"file": one["file"], "version": one["version"],
|
||||
"changes": [{"op": "edit", "key": KEY, "row": row}]}]} # fmt: skip
|
||||
assert client.post("/api/m01/save", json=body).status_code == 409 # 정본 = 개정 확인
|
||||
_post(client, "/api/m01/save", {**body, "개정확인": True})
|
||||
saved = client.get("/api/m01/logic", params={"key": KEY}).json()
|
||||
assert saved["logic"]["덧줄"][0]["식"] == TOOL_2
|
||||
sums = _post(client, "/api/m01/calc", {"key": KEY, "inputs": INPUTS})["sums"]
|
||||
assert sums["계"] == 51802 and sums["경비"] == 765 # _분석_650-H2 4 장 공구손료 2 %
|
||||
bad = copy.deepcopy(saved["logic"])
|
||||
bad["덧줄"][0]["식"] = "형틀목공 * 없는이름"
|
||||
body = {"files": [{"file": saved["file"], "version": saved["version"],
|
||||
"changes": [{"op": "edit", "key": KEY, "row": bad}]}], "개정확인": True} # fmt: skip
|
||||
before = _hashes(folder)
|
||||
assert client.post("/api/m01/save", json=body).status_code == 422
|
||||
assert _hashes(folder) == before and _hashes(REAL) == real
|
||||
|
||||
|
||||
def test_시스템_관리자가_아니면_403(folder: Path) -> None:
|
||||
app = FastAPI()
|
||||
app.include_router(
|
||||
|
||||
@@ -47,7 +47,11 @@ def test_흐름_길은_없고_표준_표는_남음(client: TestClient) -> None:
|
||||
|
||||
|
||||
def test_신규_로직은_시트_줄로_자체_GX(client: TestClient) -> None:
|
||||
version = store.read(OWN)[1] if (store.FOLDER / OWN).is_file() else ""
|
||||
version = next(
|
||||
f["version"]
|
||||
for f in client.get("/api/m01/groups/로직/files").json()["files"]
|
||||
if f["file"] == OWN
|
||||
) # 판 = 문서 파일(855 L3 ⓐ)
|
||||
row = {
|
||||
"키": "",
|
||||
"이름": "sub3임시 새 로직",
|
||||
|
||||
@@ -25,7 +25,6 @@ mf = importlib.import_module("master_formula")
|
||||
mcut = importlib.import_module("master_cut")
|
||||
meq = importlib.import_module("master_equation")
|
||||
me = importlib.import_module("master_equation_edit")
|
||||
revise = importlib.import_module("M01_MasterData.M01_MasterData_Store_Revise")
|
||||
|
||||
REAL = store.FOLDER
|
||||
EXCAVATOR, AFRAME, FORM = "GF000089", "GC001140", "GC000211"
|
||||
@@ -188,7 +187,6 @@ def test_변수표_칸은_셈_안_바꿈():
|
||||
row = dict(whole().logic(AFRAME))
|
||||
row[meq.FIELD] = {"일운반회수": {"기호": "n", "아래": "d", "이름": "하루 운반 횟수"}}
|
||||
assert raw(AFRAME, row)["계"] == raw(AFRAME)["계"]
|
||||
assert revise.row_print(row) == revise.row_print(whole().logic(AFRAME)) # M01 개정 배지 안 뜸
|
||||
|
||||
|
||||
# ── ③ 고침 ────────────────────────────────────────────────────────────
|
||||
|
||||
@@ -66,14 +66,11 @@ def test_읽기_미리셈_연결기록(client):
|
||||
assert other["셈"]["값"]["Q_조"] == other["셈"]["값"]["Q_4t^표"] > 0
|
||||
|
||||
|
||||
def test_없는문서_빈문서_없는키_404(client):
|
||||
assert (
|
||||
_read(client, "GC000100")["새"] is False
|
||||
) # 802-2a 로 문서 넣음 — 임시 사본에서 지워 빈 문서 길을 봄
|
||||
def test_문서_없는_키_404(client):
|
||||
"""855 L3 ⓐ — 기초마다 문서가 늘 있음(만들 때 문서부터) · 문서가 없으면 로직 줄로 빈 문서를 짓지 않고 404."""
|
||||
assert _read(client, "GC000100")["새"] is False
|
||||
doc_screen.drop("GC000100")
|
||||
fresh = _read(client, "GC000100")
|
||||
assert fresh["새"] is True and fresh["문서"]["식"] == [] and fresh["문서"]["금액"] == []
|
||||
assert fresh["셈"]["셈됨"] is False and fresh["셈"]["계"] is None
|
||||
assert client.get("/api/m01/logic/doc", params={"key": "GC000100"}).status_code == 404
|
||||
assert client.get("/api/m01/logic/doc", params={"key": "GX999999"}).status_code == 404
|
||||
|
||||
|
||||
|
||||
@@ -67,7 +67,11 @@ def _new_logic(c: TestClient, name: str) -> str:
|
||||
"호표": [],
|
||||
"끝수": None,
|
||||
}
|
||||
ver = store.read("로직_자체.json")[1] if (store.FOLDER / "로직_자체.json").is_file() else ""
|
||||
ver = next(
|
||||
f["version"]
|
||||
for f in c.get("/api/m01/groups/로직/files").json()["files"]
|
||||
if f["file"] == "로직_자체.json"
|
||||
) # 판 = 문서 파일(855 L3 ⓐ)
|
||||
res = c.post(
|
||||
"/api/m01/save",
|
||||
json={
|
||||
|
||||
@@ -3,8 +3,10 @@
|
||||
① 폴더 → 옛 한 파일 꼴(머리 · 줄 · 키 차례) · 옮기는 빌더 왕복 같음 · 두 번 써도 안 바뀜
|
||||
② 한 대 고침 = 파일 하나만 · 새 기계 = 파일 하나 더함(끝) · 지움 = 파일 하나 지움 · 판 충돌 409
|
||||
③ 내 기계 — 옛 `내기계.json` 은 읽을 때 폴더로 한 번 옮김(내용 · 다음 번호 같음 · 옛 파일 지움)
|
||||
④ 저장 검사 좁히기 — 옛 길(폴더 두 번 읽고 전체 검사 두 번)과 같은 오류 목록(견본 고침 스물)
|
||||
기본 = 갈래(기계 · 자재 · 인력 · 유가 · 표 · 로직 · 조합)마다 하나 이상 아홉(`SAMPLE`) · 전수 = `AISLO_TEST_ALL=1`
|
||||
④ 저장 검사 좁히기 — 옛 길(폴더 두 번 읽고 전체 검사 두 번)과 같은 판정(걸림 · 안 걸림 · 견본 고침 열일곱)
|
||||
기본 = 갈래(기계 · 자재 · 인력 · 유가 · 표 · 조합)마다 하나 이상 일곱(`SAMPLE`) · 전수 = `AISLO_TEST_ALL=1`
|
||||
(855 L3 ⓐ — 기초 연결 흠 글은 수식 문서 기준이라 옛 로직 줄 글과 꼴이 다름 → 판정만 견줌 · 기초(로직 파일) 저장은
|
||||
`Store_Logic` 길이라 로직 갈래 셋은 `test_m01_make` · `test_855_l3_doc_only` 가 봄)
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -34,8 +36,6 @@ SAMPLE = {
|
||||
"인력 준용 끊김",
|
||||
"유가 값",
|
||||
"표 조건 틀림",
|
||||
"로직 요소 끊김",
|
||||
"로직 지움(일위대가 문서가 씀)",
|
||||
"조합 지움",
|
||||
}
|
||||
|
||||
@@ -181,43 +181,12 @@ def _add(file: str, like: str, **cols) -> list[dict]:
|
||||
return [_part(file, {"op": "add", "row": row})]
|
||||
|
||||
|
||||
def _logic_with_ref() -> tuple[str, str]:
|
||||
for name, data in store._logic_files(store.loaded()[0]):
|
||||
for row in data.get("줄") or []:
|
||||
for item in row.get("호표") or []:
|
||||
if isinstance(item.get("요소"), str) and item["요소"][:2] == "LB":
|
||||
return name, str(row["키"])
|
||||
raise AssertionError("요소 줄 있는 로직 없음")
|
||||
|
||||
|
||||
def _leaf() -> tuple[str, str]:
|
||||
"""아무도 안 부르고 조합에도 없는 로직 — 일위대가 문서만 쓰게 둠."""
|
||||
files = store.loaded()[0]
|
||||
called = {k for _, calls, _ in cache.counted(store.FOLDER).values() for k in calls}
|
||||
held = {k for _, row in cm.mcb.rows(files) for k in cm.mcb.logic_keys(row)}
|
||||
for name, data in store._logic_files(files):
|
||||
for row in data.get("줄") or []:
|
||||
if str(row["키"]) not in called | held:
|
||||
return name, str(row["키"])
|
||||
raise AssertionError("잎 로직 없음")
|
||||
|
||||
|
||||
def test_narrow_check_same_as_before(master: Path, tmp_path: Path, monkeypatch) -> None:
|
||||
leaf_file, leaf = _leaf()
|
||||
doc = tmp_path / "labor.json"
|
||||
doc.write_text(json.dumps({"담은로직": [{"로직": leaf}]}), encoding="utf-8")
|
||||
monkeypatch.setattr(cache, "_labor_files", lambda: [("일위대가 시험", doc)])
|
||||
monkeypatch.setattr(cache, "_labor_files", lambda: []) # 층 일위대가 문서는 안 봄(임시 사본만)
|
||||
used = next(r["키"] for r in _rows(M) if r.get("원문번호") == "0201-0100")
|
||||
ref_file, ref_logic = _logic_with_ref()
|
||||
combo = [r["키"] for r in _rows(cm.mcb.FILE)]
|
||||
table = next(n for n in store.loaded()[0] if n.startswith("계수_"))
|
||||
cell = _rows(table)[0]["키"]
|
||||
called = "GC000268" # 317 줄이 부름
|
||||
called_file = next(
|
||||
n
|
||||
for n, d in store._logic_files(store.loaded()[0])
|
||||
if any(r["키"] == called for r in d["줄"])
|
||||
)
|
||||
|
||||
def bump(r):
|
||||
r["값"]["가격"] += 1
|
||||
@@ -237,9 +206,6 @@ def test_narrow_check_same_as_before(master: Path, tmp_path: Path, monkeypatch)
|
||||
("인력 준용 끊김", lambda: _edit(LB, "LB000006", lambda r: r.update(준용="LB999999")), True),
|
||||
("유가 값", lambda: _edit(MO, "MO000001", lambda r: r.update(값=r["값"] + 1)), False),
|
||||
("표 조건 틀림", lambda: _edit(table, cell, lambda r: r["조건"].update(sub1="모름")), True),
|
||||
("로직 요소 끊김", lambda: _edit(ref_file, ref_logic, lambda r: next(i for i in r["호표"] if str(i.get("요소", ""))[:2] == "LB").update(요소="LB999999")), True),
|
||||
("로직 지움(부름 받음)", lambda: _delete(called_file, called), True),
|
||||
("로직 지움(일위대가 문서가 씀)", lambda: _delete(leaf_file, leaf), True),
|
||||
("조합 이름 겹침", lambda: _edit(cm.mcb.FILE, combo[0], lambda r: r.update(이름=_rows(cm.mcb.FILE)[1]["이름"])), True),
|
||||
("조합 지움", lambda: _delete(cm.mcb.FILE, combo[-1]), False),
|
||||
("새 자재", lambda: _add(MT, "MT000008", 이름="sub1임시새자재"), False),
|
||||
@@ -251,5 +217,4 @@ def test_narrow_check_same_as_before(master: Path, tmp_path: Path, monkeypatch)
|
||||
batch = make()
|
||||
want = _old(batch)
|
||||
got = _new(batch)
|
||||
assert sorted(got) == sorted(want), name
|
||||
assert bool(want) == bad, (name, want[:3])
|
||||
assert bool(got) == bool(want) == bad, (name, got[:3], want[:3])
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
"""M01 [로직 복사/생성] 이 수식 문서도 같이 지음(PLAN 854-2 · 요구 896) — 사본 폴더에서만.
|
||||
|
||||
- 만들면 문서 있음 · 새 계산기 금액 = 옛 엔진 = 본뜬 로직 · 빌더가 다시 지어도 같은 글.
|
||||
- 지우면(`/logic/remove` · `/save` 지움) 문서도 없음.
|
||||
- 지우면(`/logic/remove` · `/save` 지움) 문서도 없음 · [복사/생성] = 원본 문서 복제 + 기본정보(855 L3 ⓐ).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -60,7 +60,7 @@ def _old(key: str) -> dict:
|
||||
"""옛 엔진 금액(빌더 대조와 같은 길 · 기본 입력)."""
|
||||
builder = importlib.import_module("build_수식문서_802_2")
|
||||
whole = store.loaded()[1]
|
||||
row = store.logic(key)["logic"]
|
||||
row = whole.logic(key) # 옛 로직 줄(같이 쓰기 · `/logic` 답은 머리만 · 855 L3 ⓐ)
|
||||
return _money(builder.old_answer(whole, row, builder.cases_of(whole, row)[0][1]))
|
||||
|
||||
|
||||
@@ -92,16 +92,14 @@ def test_복사로_만든_로직은_수식_문서가_있고_금액이_옛_엔진
|
||||
assert key not in doc_screen.docs()
|
||||
|
||||
|
||||
def test_식_복사로_만든_로직도_문서가_있고_save_지움이면_문서도_없다(client: TestClient) -> None:
|
||||
view = _get(client, "/api/m01/logic/formula", key=SAMPLE)
|
||||
made = _post(
|
||||
client,
|
||||
"/api/m01/logic/formula/save",
|
||||
{"로직": view["로직"], "별칭": view["별칭"], "본뜬키": SAMPLE, "이름": "sub5임시 식복사"},
|
||||
)
|
||||
def test_기본정보를_고쳐_복사해도_문서가_있고_save_지움이면_문서도_없다(client: TestClient) -> None:
|
||||
more = {"이름": "sub7임시 복사", "원문번호": "13-4-9", "결과단위": "m3", "출처": "자체 시험"}
|
||||
made = _post(client, "/api/m01/logic/copy", {"key": SAMPLE, **more}) # 855 L3 ⓐ [복사/생성]
|
||||
key = made["key"]
|
||||
assert made["수식문서"] is True and key in doc_screen.docs()
|
||||
assert _money(_get(client, "/api/m01/logic/doc", key=key)["셈"]) == _old(key)
|
||||
head = _get(client, "/api/m01/logic", key=key)["logic"]
|
||||
assert {k: head[k] for k in more} == more and head["키"] == key
|
||||
|
||||
body = {"file": make.OWN, "version": made["version"], "changes": [{"op": "delete", "key": key}]}
|
||||
_post(client, "/api/m01/save", {"files": [body]})
|
||||
|
||||
@@ -15,7 +15,7 @@ from M01_MasterData import M01_MasterData_Store as store
|
||||
from M01_MasterData import M01_MasterData_Store_Save as save_mod
|
||||
|
||||
REAL = store.FOLDER
|
||||
OWN = "로직_자체.json"
|
||||
LABOR_FILE = "인력.json"
|
||||
MACHINE = "EQ000002"
|
||||
LABOR = "LB000002" # 보통인부
|
||||
|
||||
@@ -36,37 +36,19 @@ def _bytes(folder: Path) -> dict[str, bytes]:
|
||||
return out
|
||||
|
||||
|
||||
def _new_logic() -> dict:
|
||||
def _new_labor() -> dict:
|
||||
"""새 인력 줄 — LB 키 발급 = 대장 바뀜(기초 저장은 `Store_Logic` 길 · 855 L3 ⓐ)."""
|
||||
rows = json.loads((store.FOLDER / LABOR_FILE).read_text(encoding="utf-8"))["줄"]
|
||||
seed = next(r for r in rows if r["키"] == LABOR)
|
||||
row = {k: v for k, v in seed.items() if k != "키"}
|
||||
return {
|
||||
"op": "add",
|
||||
"row": {
|
||||
"원문번호": "",
|
||||
"구분": "자체",
|
||||
"상세구분": "",
|
||||
"소유": "현장",
|
||||
"이름": "sub5임시 대장 시험",
|
||||
"결과단위": "원/㎡",
|
||||
"출처": "자체",
|
||||
"입력": [],
|
||||
"중간": [],
|
||||
"호표": [
|
||||
{
|
||||
"종류": "인력",
|
||||
"요소": LABOR,
|
||||
"이름": "보통인부",
|
||||
"단위": "인",
|
||||
"수량": "1 / 7",
|
||||
"비목": "노무비",
|
||||
}
|
||||
],
|
||||
"덧줄": [],
|
||||
"끝수": None,
|
||||
},
|
||||
"row": {**row, "원문번호": "9999", "이름": "sub7임시 인부", "출처": "자체"},
|
||||
}
|
||||
|
||||
|
||||
def _batch() -> list[dict]:
|
||||
"""기계 한 대 고침(기계 폴더) + 자체 로직 새 줄(GX 키 발급 = 대장 바뀜)."""
|
||||
"""기계 한 대 고침(기계 폴더) + 인력 새 줄(LB 키 발급 = 대장 바뀜)."""
|
||||
machine = json.loads((store.FOLDER / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8"))
|
||||
machine["비고"] = "sub5임시"
|
||||
return [
|
||||
@@ -75,7 +57,7 @@ def _batch() -> list[dict]:
|
||||
"version": store.version("기계.json"),
|
||||
"changes": [{"op": "edit", "key": MACHINE, "row": machine}],
|
||||
},
|
||||
{"file": OWN, "version": store.version(OWN), "changes": [_new_logic()]},
|
||||
{"file": LABOR_FILE, "version": store.version(LABOR_FILE), "changes": [_new_labor()]},
|
||||
]
|
||||
|
||||
|
||||
@@ -99,15 +81,37 @@ def test_파일_쓰기가_끊기면_대장과_파일이_저장_전_그대로(
|
||||
with pytest.raises(OSError):
|
||||
store.save(_batch())
|
||||
after = _bytes(master)
|
||||
assert after == before # 대장 · 기계 · 로직 파일 모두 저장 전 글 그대로
|
||||
assert after == before # 대장 · 기계 · 인력 파일 모두 저장 전 글 그대로
|
||||
assert not list(master.glob(".*.tmp")) and not list((master / "기계").glob(".*.tmp"))
|
||||
|
||||
|
||||
def test_끊김_없으면_대장과_파일이_같이_간다(master: Path) -> None:
|
||||
book_before = store.mk.load_book(master / store.mk.BOOK.name)["다음"].get("GX", 1)
|
||||
book_before = store.mk.load_book(master / store.mk.BOOK.name)["다음"].get("LB", 1)
|
||||
store.save(_batch())
|
||||
book = store.mk.load_book(master / store.mk.BOOK.name)
|
||||
keys = [r["키"] for r in json.loads((master / OWN).read_text(encoding="utf-8"))["줄"]]
|
||||
assert f"GX{book_before:06d}" in keys and book["다음"]["GX"] == book_before + 1
|
||||
keys = [r["키"] for r in json.loads((master / LABOR_FILE).read_text(encoding="utf-8"))["줄"]]
|
||||
assert f"LB{book_before:06d}" in keys and book["다음"]["LB"] == book_before + 1
|
||||
machine = json.loads((master / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8"))
|
||||
assert machine["비고"] == "sub5임시"
|
||||
|
||||
|
||||
def test_기초_문서_쓰기가_끊기면_대장과_문서가_저장_전_그대로(master: Path, monkeypatch) -> None:
|
||||
"""855 L3 ⓐ — 새 기초 = 대장 GX 발급 → 자체 문서 파일 · 문서 쓰기가 끊기면 둘 다 저장 전 글."""
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_store
|
||||
from M01_MasterData import M01_MasterData_Store_Logic as logic_store
|
||||
|
||||
shutil.copytree(REAL / "수식문서", master / "수식문서")
|
||||
monkeypatch.setattr(doc_store.ml, "FOLDER", master / "수식문서")
|
||||
doc_store._memo.clear()
|
||||
before = _bytes(master) | {p.name: p.read_bytes() for p in (master / "수식문서").glob("*.json")}
|
||||
|
||||
def broken(path, data):
|
||||
raise OSError("디스크 흉내 실패")
|
||||
|
||||
monkeypatch.setattr(doc_store, "put", broken)
|
||||
row = {"키": "", "이름": "sub7임시 기초", "원문번호": "", "결과단위": "원", "출처": "자체"}
|
||||
part = {"file": "로직_자체.json", "version": doc_store.file_version("로직_자체.json")}
|
||||
with pytest.raises(OSError):
|
||||
logic_store.save([{**part, "changes": [{"op": "add", "row": row}]}])
|
||||
after = _bytes(master) | {p.name: p.read_bytes() for p in (master / "수식문서").glob("*.json")}
|
||||
assert after == before
|
||||
|
||||
@@ -0,0 +1,150 @@
|
||||
"""855 L3 ⓐ 지킴 — M01 단가산출 기초가 수식 문서만으로 돎(로직 JSON 은 같이 쓰기만).
|
||||
|
||||
마스터 사본 두 벌에서 같은 차례로 부름 — 켬(로직 파일 있음 · 같이 쓰기 켬) / 끔(로직 파일 없음 ·
|
||||
`Store_Logic.WRITE` 끔). 목록 · 상세 · 비고 [저장] · 개정 확인 409 · 판 409 · 별칭 · [신규] ·
|
||||
[복사/생성] · [삭제] · 기계 등록 답이 두 벌 같음.
|
||||
다른 자리(둘째 박자에서 걷을 것) = `/logic/doc` 의 「층바탕」(빌더 문서 = 옛 로직 줄 변환)만 — 빼고 견줌.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import shutil
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
from fastapi import Depends, FastAPI
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from common_util import common_util_auth as auth
|
||||
from M01_MasterData import M01_MasterData_Alias as alias
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_store
|
||||
from M01_MasterData import M01_MasterData_Router as router_module
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
from M01_MasterData import M01_MasterData_Store_Logic as logic_store
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "master_data/scripts"))
|
||||
import master_doc_link as mdl # noqa: E402
|
||||
|
||||
REAL = store.FOLDER
|
||||
CANON = "GF000219" # 산림 13-4-1 메쌓기(인력) — 정본 기초
|
||||
MACHINE, FAMILY = "기계.json", "GC000268" # [새 기계] = 꼴 식 고르기 목록 등록
|
||||
|
||||
|
||||
def _world(tmp: Path, monkeypatch, logic: bool) -> TestClient:
|
||||
for path in REAL.glob("*.json"):
|
||||
if path.name.startswith("로직_") and not logic:
|
||||
continue
|
||||
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
|
||||
shutil.copy(path, tmp / path.name)
|
||||
shutil.copytree(REAL / "기계", tmp / "기계")
|
||||
shutil.copytree(REAL / "수식문서", tmp / "수식문서")
|
||||
monkeypatch.setattr(store, "FOLDER", tmp)
|
||||
monkeypatch.setattr(doc_store.ml, "FOLDER", tmp / "수식문서")
|
||||
monkeypatch.setattr(mdl, "FOLDER", tmp / "수식문서")
|
||||
monkeypatch.setattr(logic_store, "WRITE", logic)
|
||||
doc_store._memo.clear()
|
||||
store.cache.forget() # 앞 시험이 남긴 기억 없이
|
||||
app = FastAPI()
|
||||
app.dependency_overrides[auth.verify_session] = lambda: {
|
||||
"user_id": 1, "name": "시험", "role": "SYSTEM_ADMIN", "company_id": 1,
|
||||
} # fmt: skip
|
||||
deps = [Depends(auth.verify_session), Depends(auth.require_system_admin)]
|
||||
app.include_router(router_module.router, dependencies=deps)
|
||||
app.include_router(alias.router, dependencies=deps)
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _run(client: TestClient) -> list:
|
||||
out: list = []
|
||||
|
||||
def call(method: str, url: str, body=None, **params):
|
||||
res = client.request(method, url, json=body, params=params or None)
|
||||
got = res.json()
|
||||
if isinstance(got, dict):
|
||||
got.pop("층바탕", None) # 빌더 문서(옛 로직 줄 변환) — 둘째 박자에서 걷음
|
||||
out.append((method, url, res.status_code, got))
|
||||
return got
|
||||
|
||||
def save(file: str, version: str, changes: list, ok: bool = True) -> dict:
|
||||
body = {"files": [{"file": file, "version": version, "changes": changes}], "개정확인": ok}
|
||||
return call("POST", "/api/m01/save", body)
|
||||
|
||||
call("GET", "/api/m01/logics")
|
||||
call("GET", "/api/m01/logics", q="메쌓기")
|
||||
call("GET", "/api/m01/groups/로직/files")
|
||||
one = call("GET", "/api/m01/logic", key=CANON)
|
||||
call("GET", "/api/m01/logic/doc", key=CANON)
|
||||
row = {**one["logic"], "비고": "sub7임시 비고"}
|
||||
edit = [{"op": "edit", "key": CANON, "row": row}]
|
||||
save(one["file"], one["version"], edit, ok=False) # 개정 확인 없음 = 409
|
||||
saved = save(one["file"], one["version"], edit)
|
||||
save(one["file"], one["version"], edit) # 옛 판 = 409
|
||||
call("GET", "/api/m01/logic", key=CANON)
|
||||
back = [{"op": "edit", "key": CANON, "row": one["logic"]}]
|
||||
save(one["file"], saved["files"][0]["version"], back)
|
||||
call("POST", "/api/m01/alias/save", {"키": CANON, "별칭": "sub7임시별칭"})
|
||||
call("GET", "/api/m01/alias")
|
||||
call("POST", "/api/m01/alias/save", {"키": CANON, "별칭": ""})
|
||||
call("GET", "/api/m01/logic", key=CANON)
|
||||
|
||||
own = next(
|
||||
f
|
||||
for f in call("GET", "/api/m01/groups/로직/files")["files"]
|
||||
if f["file"] == "로직_자체.json"
|
||||
)
|
||||
new = {"키": "", "이름": "sub7임시 신규", "원문번호": "", "결과단위": "m3", "출처": "자체"}
|
||||
made = save("로직_자체.json", own["version"], [{"op": "add", "row": new}])
|
||||
key = made["added"][-1]["key"]
|
||||
call("GET", "/api/m01/logic", key=key)
|
||||
call("GET", "/api/m01/logic/doc", key=key)
|
||||
copied = call("POST", "/api/m01/logic/copy", {"key": CANON, "이름": "sub7임시 복사"})
|
||||
call("GET", "/api/m01/logic/doc", key=copied["key"])
|
||||
for gone in (key, copied["key"]):
|
||||
info = call("GET", "/api/m01/logic", key=gone)
|
||||
body = {"key": gone, "file": info["file"], "version": info["version"]}
|
||||
call("POST", "/api/m01/logic/remove", body)
|
||||
call("GET", "/api/m01/logics", q="sub7임시")
|
||||
|
||||
seed = call("GET", "/api/m01/machine/row", key="EQ000022")
|
||||
first = json.loads(json.dumps(seed["row"]))
|
||||
machine = {
|
||||
**first,
|
||||
"키": "",
|
||||
"원문번호": "9999-0855",
|
||||
"이름": "sub7임시기계",
|
||||
"출처": {},
|
||||
"단위": {},
|
||||
}
|
||||
machine.pop("별칭", None)
|
||||
save(MACHINE, seed["version"], [{"op": "add", "row": machine}])
|
||||
picks = call("GET", "/api/m01/logic/doc", key=FAMILY)
|
||||
assert "9999-0855" in json.dumps(picks["문서"], ensure_ascii=False)
|
||||
rows = store.read(MACHINE)[0]["줄"]
|
||||
eq = next(r["키"] for r in rows if r.get("원문번호") == "9999-0855")
|
||||
save(MACHINE, store.version(MACHINE), [{"op": "delete", "key": eq}])
|
||||
call("GET", "/api/m01/logic/doc", key=FAMILY)
|
||||
return out
|
||||
|
||||
|
||||
def test_로직_파일_없이_같이_쓰기_끄고도_답이_같음(tmp_path: Path, monkeypatch) -> None:
|
||||
(tmp_path / "on").mkdir()
|
||||
(tmp_path / "off").mkdir()
|
||||
with monkeypatch.context() as m:
|
||||
on = _run(_world(tmp_path / "on", m, logic=True))
|
||||
with monkeypatch.context() as m:
|
||||
off = _run(_world(tmp_path / "off", m, logic=False))
|
||||
assert [c[2] for c in on] == [c[2] for c in off]
|
||||
assert [c[2] for c in on].count(409) == 2 # 개정 확인 · 옛 판
|
||||
assert not [c for c in on if c[2] >= 400 and c[2] != 409], on
|
||||
for a, b in zip(on, off, strict=True):
|
||||
if a != b and isinstance(a[3], dict) and "logics" in a[3]:
|
||||
x, y = a[3]["logics"], b[3]["logics"]
|
||||
hit = next(((p, q) for p, q in zip(x, y) if p != q), (len(x), len(y)))
|
||||
raise AssertionError((a[:3], hit))
|
||||
assert a == b, (
|
||||
a[:3],
|
||||
json.dumps(a[3], ensure_ascii=False)[:300],
|
||||
json.dumps(b[3], ensure_ascii=False)[:300],
|
||||
)
|
||||
assert not list((tmp_path / "off").glob("로직_*.json")) # 끔 = 로직 파일을 만들지 않음
|
||||
@@ -62,6 +62,12 @@ def _get(client: TestClient, url: str, **params) -> dict:
|
||||
return res.json()
|
||||
|
||||
|
||||
def _row(file: str, key: str) -> dict:
|
||||
"""옛 로직 줄(같이 쓰기 사본) — `/logic` 답은 머리만(855 L3 ⓐ) · 옛 셈 길 시험 몫."""
|
||||
rows = json.loads((store.FOLDER / file).read_text(encoding="utf-8"))["줄"]
|
||||
return next(r for r in rows if r["키"] == key)
|
||||
|
||||
|
||||
def _calc(client: TestClient, **inputs) -> dict:
|
||||
res = client.post(
|
||||
"/api/m01/calc",
|
||||
@@ -264,7 +270,8 @@ def test_단가_자동_요소_찾기_저장전_시험계산(client: TestClient)
|
||||
assert tables["items"] and all(x["값칸"] for x in tables["items"])
|
||||
raw = (store.FOLDER / one["file"]).read_bytes()
|
||||
before = _calc(client)["sums"]["계"]
|
||||
half = {**one["logic"], "호표": one["logic"]["호표"][:1]} # 보통인부 줄 뺌
|
||||
row = _row(one["file"], LOGIC_KEY)
|
||||
half = {**row, "호표": row["호표"][:1]} # 보통인부 줄 뺌
|
||||
res = client.post(
|
||||
"/api/m01/calc",
|
||||
json={"key": LOGIC_KEY, "inputs": LOGIC_INPUTS, "row": half},
|
||||
@@ -390,7 +397,7 @@ def test_전력은_계약종별을_골라야_값이_섬(client: TestClient) -> N
|
||||
계산은 로직 입력으로 값이 섬(mf.element 로 직접 확인)."""
|
||||
one = _get(client, "/api/m01/logic", key=key_of("GC000893"))
|
||||
cond = {"이름": "전력량요금", "계약종별": "입력"}
|
||||
assert "전력 계약종별" in {x["이름"] for x in one["logic"]["입력"]}
|
||||
assert "전력 계약종별" in {x["이름"] for x in _row(one["file"], one["logic"]["키"])["입력"]}
|
||||
with pytest.raises(store.cm.mf.FormulaError, match="전력 계약종별"):
|
||||
store.cm.mf.element(store.cm.master(), cond, {})
|
||||
value, source = store.cm.mf.element(store.cm.master(), cond, {"전력 계약종별": "주택용 저압"})
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
목록(`/logics` · `/combos`)은 요청마다 마스터를 새로 읽지 않고 막힘도 미리 세어 둔 값을 씀.
|
||||
여기서 보는 것 = ① 세어 둔 값이 줄마다 검사한 것과 같음 ② 파일이 바뀌면 바로 다시 읽음
|
||||
③ 저장 직후 목록에 바로 비침 ④ 다른 파일의 로직이 바뀌면 그것을 부르던 줄도 다시 셈
|
||||
⑤ 저장 검사를 고친 줄 둘레로 좁혀도 흠(없는 키 · 없는 요소 · 돌고 도는 참조)을 그대로 잡음.
|
||||
⑤ 요소 저장 검사를 좁혀도 흠을 그대로 잡음(기초 셈 칸 고침 검사 = 문서 저장 몫 · 855 L3 ⓐ).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -129,74 +129,11 @@ def test_부르는_로직이_바뀌면_다른_파일의_줄도_다시_센다(
|
||||
assert caller["blocked"] is True and any("입력 「지역」" in x for x in caller["reasons"])
|
||||
|
||||
|
||||
def _save(client: TestClient, key: str, spoil) -> object:
|
||||
"""그 로직 줄을 고쳐 저장 길로 보냄 — 저장 검사가 흠을 잡는지 보려고."""
|
||||
one = client.get("/api/m01/logic", params={"key": key}).json()
|
||||
row = json.loads(json.dumps(one["logic"], ensure_ascii=False))
|
||||
spoil(row)
|
||||
return client.post(
|
||||
"/api/m01/save",
|
||||
json={
|
||||
"files": [
|
||||
{
|
||||
"file": one["file"],
|
||||
"version": one["version"],
|
||||
"changes": [{"op": "edit", "key": key, "row": row}],
|
||||
}
|
||||
],
|
||||
"개정확인": True, # 정본 줄 고침 = 개정 확인(713-1)
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def _errors(res) -> list[str]:
|
||||
assert res.status_code == 422, res.text
|
||||
return res.json()["detail"]["errors"]
|
||||
|
||||
|
||||
def test_저장_검사를_좁혀도_흠을_잡는다(client: TestClient) -> None:
|
||||
"""고친 줄과 그 줄을 부르던 줄만 검사하지만 없는 키 · 없는 요소는 그대로 걸림."""
|
||||
_logics(client) # 미리 세어 둔 값이 선 평소 모양
|
||||
|
||||
def no_logic(row: dict) -> None:
|
||||
at = next(i for i, h in enumerate(row["호표"]) if h["종류"] == "로직")
|
||||
row["호표"][at]["요소"] = "로직(GC999999, 기계='5401-0017', 지역=지역)"
|
||||
|
||||
def no_element(row: dict) -> None:
|
||||
at = next(i for i, h in enumerate(row["호표"]) if h["종류"] == "인력")
|
||||
row["호표"][at]["요소"] = "LB999999"
|
||||
|
||||
for spoil, word in ((no_logic, "GC999999"), (no_element, "LB999999")):
|
||||
assert any(word in x for x in _errors(_save(client, CALLER, spoil)))
|
||||
|
||||
|
||||
def test_돌고_도는_참조도_저장이_막는다(client: TestClient) -> None:
|
||||
_logics(client)
|
||||
|
||||
def call_back(row: dict) -> None:
|
||||
row.setdefault("호표", []).append(
|
||||
{
|
||||
"종류": "로직",
|
||||
"요소": f"로직({CALLER}, 지반구분='토사', 크레인='2104-0010', 지역=지역)",
|
||||
"이름": "되부르기",
|
||||
"단위": "시간",
|
||||
"수량": "1",
|
||||
}
|
||||
)
|
||||
|
||||
assert any("돌고 도는" in x for x in _errors(_save(client, CALLEE, call_back)))
|
||||
|
||||
|
||||
def test_고친_줄을_부르던_줄이_깨지면_저장이_막힌다(client: TestClient) -> None:
|
||||
"""좁힌 검사가 「그 줄을 부르는 줄」 을 빠뜨리지 않는지 — 다른 파일에 있는 줄."""
|
||||
_logics(client)
|
||||
|
||||
def add_input(row: dict) -> None:
|
||||
row["입력"] = [*row.get("입력", []), {"이름": "새입력", "종류": "수"}]
|
||||
|
||||
assert any("새입력" in x for x in _errors(_save(client, CALLEE, add_input)))
|
||||
|
||||
|
||||
def test_미리_읽어_두면_첫_목록이_기다리지_않는다(client: TestClient) -> None:
|
||||
store.cache.forget()
|
||||
thread = store.cache.warm(store.FOLDER)
|
||||
|
||||
@@ -1,119 +1,21 @@
|
||||
"""M01 복사해서 만들기(PLAN 3-4) — 별칭 꼴 식 펴기 · 되돌려 자체 로직으로 저장.
|
||||
"""master_copy 펴기 · 되돌리기 왕복(PLAN 3-4) — 로직 전부가 펴고 되돌리면 원래 식 글자 그대로.
|
||||
|
||||
계약 `resources/master_data/_화면_계약.md` 7장 · 규칙 `resources/master_data/ref/_설계_식_복사.md`.
|
||||
못박는 것
|
||||
- 13-4-1 을 식으로 펴 아무것도 안 고치고 되돌려 저장하면 원본과 계산 결과가 같음.
|
||||
- 12-4 처럼 같은 표를 다른 인자로 쓰는 로직은 별칭이 찾은 줄 값으로 갈림.
|
||||
- 로직 전부(1,354줄)가 펴고 되돌리면 원래 식 글자 그대로 돌아옴.
|
||||
M01 [복사/생성] 옛 시트 길(`/logic/formula*`)은 855 L3 ⓐ 에서 걷음(문서 복제 = `test_854_2_m01_copy_doc`) ·
|
||||
`master_copy` 는 M02 `Sangeun_Formula` · `master_text` 가 아직 씀 — 로직 JSON 을 걷는 둘째 박자에서 이 시험도 걷음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import shutil
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from fastapi import FastAPI
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from M01_MasterData import M01_MasterData_Router as router_module
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "master_data/scripts"))
|
||||
|
||||
import master_copy as mcp # noqa: E402
|
||||
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
|
||||
|
||||
REAL = store.FOLDER
|
||||
STACK = "GF000219" # 13-4-1 메쌓기(인력) — 같은 표를 같은 인자로 두 번(별칭 하나로 합침)
|
||||
FORM = "GF000160" # 12-4 합판거푸집 — 같은 표를 다른 인자로 일곱 번(번호로 갈림)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client(tmp_path: Path, monkeypatch) -> TestClient:
|
||||
for path in REAL.glob("*.json"):
|
||||
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
|
||||
shutil.copy(path, tmp_path / path.name)
|
||||
shutil.copytree(REAL / "기계", tmp_path / "기계") # 기계 = 폴더(826-2)
|
||||
monkeypatch.setattr(store, "FOLDER", tmp_path)
|
||||
shutil.copytree(REAL / "수식문서", tmp_path / "수식문서") # 로직 목록 = 수식 문서(855 L2 ⓐ)
|
||||
monkeypatch.setattr(store._docs().ml, "FOLDER", tmp_path / "수식문서")
|
||||
app = FastAPI()
|
||||
app.include_router(router_module.router)
|
||||
app.include_router(old_engine.router)
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _get(client: TestClient, url: str, **params) -> dict:
|
||||
res = client.get(url, params=params)
|
||||
assert res.status_code == 200, res.text
|
||||
return res.json()
|
||||
|
||||
|
||||
def _post(client: TestClient, url: str, body: dict, want: int = 200) -> dict:
|
||||
res = client.post(url, json=body)
|
||||
assert res.status_code == want, res.text
|
||||
return res.json()
|
||||
|
||||
|
||||
def _inputs(key: str) -> dict:
|
||||
"""그 로직의 일괄 시험 입력 한 벌(`check_master.시험입력`)."""
|
||||
row = store.cm.master(REAL).logic(key)
|
||||
return {k: str(v) for k, v in store.cm.시험입력(row).items()}
|
||||
|
||||
|
||||
def _sums(client: TestClient, key: str, inputs: dict) -> dict:
|
||||
got = _post(client, "/api/m01/calc", {"key": key, "inputs": inputs})
|
||||
assert got["ok"] is True, got
|
||||
return got["sums"]
|
||||
|
||||
|
||||
# ── 펴기 ──────────────────────────────────────────────────────────────
|
||||
def test_별칭이_식에서_이름_하나로_보이고_원문은_뒤에_남는다(client: TestClient) -> None:
|
||||
got = _get(client, "/api/m01/logic/formula", key=STACK)
|
||||
names = {one["이름"]: one for one in got["별칭"]}
|
||||
assert set(names) == {"메쌓기인력", "높이에대한증가율표"}
|
||||
|
||||
hit = names["메쌓기인력"]
|
||||
assert hit["참조"] == "QF000421"
|
||||
assert hit["원문"] == "찾기(QF000421, 뒷길이=뒷길이, 돌=돌, 쌓기=쌓기)"
|
||||
assert hit["자리"] == ["호표[0].수량", "호표[1].수량"] # 완전히 같은 부르기는 하나로 합침
|
||||
assert "석공" in hit["값칸"]
|
||||
|
||||
가로 = {one["자리"]: one["식"] for one in got["줄"]}
|
||||
assert 가로["호표[0].수량"] == "메쌓기인력.석공 * (1 + 증가율 / 100)" # 값 칸은 그대로 둠
|
||||
assert "찾기(" not in 가로["중간[0].식"]
|
||||
assert "높이에대한증가율표.증가율" in 가로["중간[0].식"]
|
||||
|
||||
|
||||
def test_같은_표를_다른_인자로_쓰면_별칭이_찾은_줄_값으로_갈린다(client: TestClient) -> None:
|
||||
got = _get(client, "/api/m01/logic/formula", key=FORM)
|
||||
형틀 = [one for one in got["별칭"] if one["참조"] == "QF000357"]
|
||||
assert [one["이름"] for one in 형틀] == [
|
||||
f"합판거푸집_{n}" for n in ("합판", "각재", "철선", "못", "박리제", "형틀목공", "보통인부")
|
||||
]
|
||||
assert [one["원문"] for one in 형틀][:2] == [
|
||||
"찾기(QF000357, 구분='합판')",
|
||||
"찾기(QF000357, 구분='각재')",
|
||||
]
|
||||
# 같은 표를 같은 인자로 두 번 쓰는 자리(QF000358)는 번호 없이 하나
|
||||
한벌 = [one for one in got["별칭"] if one["참조"] == "QF000358"]
|
||||
assert len(한벌) == 1 and 한벌[0]["자리"] == ["중간[0].식", "중간[1].식"]
|
||||
|
||||
가로 = {one["자리"]: one["식"] for one in got["줄"]}
|
||||
assert 가로["호표[0].수량"] == "합판거푸집_합판.기준수량_1회사용 * 재료율"
|
||||
assert 가로["호표[1].수량"] == "합판거푸집_각재.기준수량_1회사용 * 재료율"
|
||||
|
||||
|
||||
def test_로직_부르기도_별칭으로_보인다(client: TestClient) -> None:
|
||||
got = _get(client, "/api/m01/logic/formula", key="GC000994")
|
||||
부름 = [one for one in got["별칭"] if one["종류"] == "로직"]
|
||||
assert 부름, got["별칭"]
|
||||
assert all(one["원문"].startswith("로직(") for one in 부름)
|
||||
요소 = [one.get("요소") for one in got["줄"] if one["갈래"] == "호표"]
|
||||
assert any(str(one) in {x["이름"] for x in 부름} for one in 요소) # 호표 요소도 별칭으로
|
||||
|
||||
|
||||
def test_로직_전부가_펴고_되돌리면_원래_식으로_돌아온다() -> None:
|
||||
@@ -128,140 +30,3 @@ def test_로직_전부가_펴고_되돌리면_원래_식으로_돌아온다() ->
|
||||
bad += mcp.check(master, row)
|
||||
assert rows > 1000, rows
|
||||
assert not bad, bad[:5]
|
||||
|
||||
|
||||
# ── 되돌려 저장 ────────────────────────────────────────────────────────
|
||||
def test_안_고치고_되돌려_저장하면_원본과_계산이_같다(client: TestClient) -> None:
|
||||
inputs = _inputs(STACK)
|
||||
was = _sums(client, STACK, inputs)
|
||||
|
||||
view = _get(client, "/api/m01/logic/formula", key=STACK)
|
||||
made = _post(
|
||||
client,
|
||||
"/api/m01/logic/formula/save",
|
||||
{"로직": view["로직"], "별칭": view["별칭"], "본뜬키": STACK, "이름": "메쌓기 복사본"},
|
||||
)
|
||||
key = made["key"]
|
||||
assert key.startswith("GX"), made
|
||||
assert made["logic"]["소유"] == "현장" and made["logic"]["구분"] == "자체"
|
||||
assert f"{STACK} 를 본뜸" in made["logic"]["비고"]
|
||||
|
||||
# 별칭은 저장되지 않음 — 식은 원문 그대로
|
||||
식 = made["logic"]["호표"][0]["수량"]
|
||||
assert 식 == "찾기(QF000421, 뒷길이=뒷길이, 돌=돌, 쌓기=쌓기).석공 * (1 + 증가율 / 100)"
|
||||
assert Decimal(str(_sums(client, key, inputs)["계"])) == Decimal(str(was["계"]))
|
||||
assert Decimal(str(was["계"])) > 0
|
||||
|
||||
# 원본은 그대로
|
||||
assert _get(client, "/api/m01/logic", key=STACK)["logic"]["호표"][0]["수량"] == 식
|
||||
|
||||
|
||||
def test_식을_고쳐_저장하면_그_값으로_계산된다(client: TestClient) -> None:
|
||||
inputs = _inputs(FORM)
|
||||
was = _sums(client, FORM, inputs)
|
||||
|
||||
view = _get(client, "/api/m01/logic/formula", key=FORM)
|
||||
row = view["로직"]
|
||||
row["호표"][6]["수량"] = (
|
||||
"합판거푸집_형틀목공.기준수량_1회사용 * 인력율 * 2" # 형틀목공 품 두 배
|
||||
)
|
||||
made = _post(
|
||||
client,
|
||||
"/api/m01/logic/formula/save",
|
||||
{"로직": row, "별칭": view["별칭"], "본뜬키": FORM},
|
||||
)
|
||||
saved = made["logic"]["호표"][6]["수량"]
|
||||
assert saved == "찾기(QF000357, 구분='형틀목공').기준수량_1회사용 * 인력율 * 2"
|
||||
|
||||
now = _sums(client, made["key"], inputs)
|
||||
assert Decimal(str(now["노무비"])) > Decimal(str(was["노무비"]))
|
||||
assert Decimal(str(now["재료비"])) == Decimal(str(was["재료비"]))
|
||||
|
||||
|
||||
def test_별칭과_같은_이름의_사용자_변수를_만들면_저장을_막는다(client: TestClient) -> None:
|
||||
"""일감 15 — 교차 검증 어긋남 1건. 가림 못 하는 이름 겹침은 조용히 안 바꾸고 막음."""
|
||||
view = _get(client, "/api/m01/logic/formula", key=STACK)
|
||||
row = view["로직"]
|
||||
row["중간"].insert(0, {"이름": "메쌓기인력", "식": "1"}) # 별칭과 같은 이름
|
||||
for h in row["호표"]:
|
||||
if h["이름"] == "석공":
|
||||
h["수량"] = "메쌓기인력 * 2"
|
||||
got = _post(
|
||||
client,
|
||||
"/api/m01/logic/formula/save",
|
||||
{"로직": row, "별칭": view["별칭"], "본뜬키": STACK},
|
||||
want=400,
|
||||
)
|
||||
assert "메쌓기인력" in str(got["detail"])
|
||||
# 미리보기 길도 같이 막힘
|
||||
got2 = _post(
|
||||
client, "/api/m01/logic/formula/preview", {"로직": row, "별칭": view["별칭"]}, want=400
|
||||
)
|
||||
assert "메쌓기인력" in str(got2["detail"])
|
||||
|
||||
|
||||
def test_별칭_원문이_부르기가_아니면_막는다(client: TestClient) -> None:
|
||||
view = _get(client, "/api/m01/logic/formula", key=STACK)
|
||||
marks = [{**one} for one in view["별칭"]]
|
||||
marks[0]["원문"] = "1 + 1"
|
||||
got = _post(
|
||||
client,
|
||||
"/api/m01/logic/formula/save",
|
||||
{"로직": view["로직"], "별칭": marks},
|
||||
want=400,
|
||||
)
|
||||
assert "찾기" in str(got["detail"])
|
||||
|
||||
|
||||
def test_미리보기는_저장_없이_원문으로_되돌린_로직과_지을_문서를_준다(client: TestClient) -> None:
|
||||
"""3-4 화면의 [시험 계산] 이 쓰는 길(855 2-B4) — 답의 `문서` 를 문서 셈(`/logic/doc/preview`)
|
||||
으로 · 금액 = 그 로직 수식 문서 금액(옵션을 바꿔도)."""
|
||||
view = _get(client, "/api/m01/logic/formula", key=STACK)
|
||||
before_keys = _get(client, "/api/m01/logics")["logics"]
|
||||
preview = _post(
|
||||
client, "/api/m01/logic/formula/preview", {"로직": view["로직"], "별칭": view["별칭"]}
|
||||
)
|
||||
resolved = preview["logic"]["호표"][0]["수량"]
|
||||
assert resolved == "찾기(QF000421, 뒷길이=뒷길이, 돌=돌, 쌓기=쌓기).석공 * (1 + 증가율 / 100)"
|
||||
after_keys = _get(client, "/api/m01/logics")["logics"]
|
||||
assert after_keys == before_keys # 아무것도 저장 안 함
|
||||
|
||||
def total(doc: dict, given: dict) -> Decimal:
|
||||
got = _post(client, "/api/m01/logic/doc/preview", {"문서": doc, "입력": given})
|
||||
assert got["셈"]["셈됨"], got["셈"]
|
||||
return Decimal(str(got["셈"]["계"]))
|
||||
|
||||
saved = _get(client, "/api/m01/logic/doc", key=STACK)["문서"]
|
||||
draft = {**preview["문서"], "키": "_새"} # 화면이 보내는 꼴(저장 전 = 빈 키)
|
||||
picks = [total(saved, {})]
|
||||
for given in ({}, {"돌": "견치돌", "쌓기": "켜쌓기", "뒷길이": 45}):
|
||||
assert total(draft, given) == total(saved, given)
|
||||
picks.append(total(saved, given))
|
||||
assert picks[0] != picks[-1] # 옵션이 금액을 바꿈(같음이 빈 대조가 아님)
|
||||
|
||||
|
||||
def test_미리보기도_별칭_원문이_부르기가_아니면_막는다(client: TestClient) -> None:
|
||||
view = _get(client, "/api/m01/logic/formula", key=STACK)
|
||||
marks = [{**one} for one in view["별칭"]]
|
||||
marks[0]["원문"] = "아무거나"
|
||||
got = _post(
|
||||
client,
|
||||
"/api/m01/logic/formula/preview",
|
||||
{"로직": view["로직"], "별칭": marks},
|
||||
want=400,
|
||||
)
|
||||
assert "찾기" in str(got["detail"])
|
||||
|
||||
|
||||
def test_정본_로직은_이_길로도_안_바뀐다(client: TestClient) -> None:
|
||||
"""저장은 늘 새 자체 로직(`GX`) — 본뜬 원본 파일은 판본까지 그대로."""
|
||||
before = _get(client, "/api/m01/logic", key=STACK)
|
||||
view = _get(client, "/api/m01/logic/formula", key=STACK)
|
||||
_post(
|
||||
client,
|
||||
"/api/m01/logic/formula/save",
|
||||
{"로직": view["로직"], "별칭": view["별칭"], "본뜬키": STACK},
|
||||
)
|
||||
after = _get(client, "/api/m01/logic", key=STACK)
|
||||
assert after["version"] == before["version"]
|
||||
assert after["logic"] == before["logic"]
|
||||
|
||||
@@ -164,10 +164,15 @@ def test_모르는_소유는_400(client: TestClient) -> None:
|
||||
assert caught.value.status == 400
|
||||
|
||||
|
||||
def test_만든_자체_로직이_시험_계산에_돈다(client: TestClient) -> None:
|
||||
def test_만든_자체_로직은_빈_문서로_열리고_목록에_든다(client: TestClient) -> None:
|
||||
"""855 L3 ⓐ — 새 기초 셈은 문서(줄 쌓기) 몫 · 받은 줄의 셈 칸은 안 씀(옛 「시험 계산에 돈다」 걷음)."""
|
||||
made = _new("공용")
|
||||
got = _post(client, "/api/m01/calc", {"key": made["key"], "inputs": {}})
|
||||
assert got["ok"] is True and Decimal(str(got["sums"]["노무비"])) > 0
|
||||
got = _get(client, "/api/m01/logic/doc", key=made["key"])
|
||||
assert (
|
||||
got["새"] is False
|
||||
and got["파일"] == "수식_자체.json"
|
||||
and got["문서"]["이름"] == "시험 초안"
|
||||
)
|
||||
listed = _get(client, "/api/m01/logics", owner="공용")["logics"]
|
||||
assert made["key"] in [x["키"] for x in listed]
|
||||
|
||||
|
||||
@@ -6,6 +6,7 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import shutil
|
||||
import sys
|
||||
@@ -45,6 +46,12 @@ def client(tmp_path: Path, monkeypatch) -> TestClient:
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _row(file: str, key: str) -> dict:
|
||||
"""옛 로직 줄(같이 쓰기 사본) — `/logic` 답은 머리만(855 L3 ⓐ) · 옛 글 길 시험 몫."""
|
||||
rows = json.loads((store.FOLDER / file).read_text(encoding="utf-8"))["줄"]
|
||||
return next(r for r in rows if r["키"] == key)
|
||||
|
||||
|
||||
def _inputs(key: str) -> dict:
|
||||
"""그 로직의 일괄 시험 입력 한 벌(`check_master.시험입력`)."""
|
||||
row = store.cm.master(REAL).logic(key)
|
||||
@@ -166,7 +173,7 @@ def test_고른_값이_틀리면_그대로_막힘(client: TestClient) -> None:
|
||||
|
||||
def test_끝수는_줄이_아니라_소계에_붙는다(client: TestClient) -> None:
|
||||
got = client.get("/api/m01/logic", params={"key": STACK}).json()
|
||||
row = dict(got["logic"], 끝수={"대상": "계", "자리": 0, "방법": "버림"})
|
||||
row = dict(_row(got["file"], STACK), 끝수={"대상": "계", "자리": 0, "방법": "버림"})
|
||||
body = {"key": STACK, "inputs": _inputs(STACK), "row": row, "file": got["file"]}
|
||||
cut = client.post("/api/m01/text", json=body).json()
|
||||
assert cut["ok"] is True
|
||||
@@ -301,7 +308,7 @@ def test_조각_로직_부르는_줄_990개_세_비목에_다_걸치고_계산_
|
||||
비목이 안 정해진 로직 부르는 줄은 세 비목에 다 걸쳐 보여야 하나, 이 견본(STACK)은
|
||||
호표 둘 다 비목이 「노무비」로 정해진 인력 줄이라 한 비목에만 걸림 — 그 좁은 경우 확인."""
|
||||
got = client.get("/api/m01/logic", params={"key": STACK}).json()
|
||||
row = dict(got["logic"])
|
||||
row = dict(_row(got["file"], STACK))
|
||||
row["호표"] = [dict(row["호표"][0], 요소="LB099999"), dict(row["호표"][1])]
|
||||
body = {"key": STACK, "inputs": _inputs(STACK), "row": row, "file": got["file"]}
|
||||
text = client.post("/api/m01/text", json=body)
|
||||
|
||||
Reference in New Issue
Block a user