test(855-E 2-E4 ㉯-2): 옛 M01 셈 길 도우미 은퇴 · test_m01_* 를 문서 셈 · 바탕으로

- helper_855_old_engine_routes git rm — 2-E1 에서 서버에서 걷은 /calc · /text · /logic/auto 몸(시험 전용) · 부르는 곳 0
- test_m01_text git rm — 옛 계산서 글 엔진(master_text · master_copy) 자체만 봄(로직 줄 0 이면 빈 통과) · 계산서 글 = 문서 글(master_doc_text · test_855_c4_doc_text)
- test_m01_auto: 자동값 = 문서 자동값(Doc_Copy.auto_of) · 견본 금액 · 빈 줄 · 원 입력 · 체인톱 품목 = 문서 셈(셈 기록) · 고름 = Labor_Copy.line · 없는 로직 = 문서 없음(14 통과)
- test_m01_pick: 검색어 · 지역 낱말 · 고름 · 단위 환산 · 단위 경고 · 후보 없음 = master_pick.priced(문서 셈이 쓰는 바탕) · 기계 입력(목록 밖 · EQ 키) = 문서 셈 · 품목 칸 = 셈 기록
- test_m01_api: 셈 = 임시 사본 색인 문서 셈 · 저장 뒤 +40 원 · 옛 길 고유 뜻(글자 수 받기 · 모르는 입력 · 저장 전 로직 줄 시험계산) 지움 · 전력 입력 = 문서 변수
- test_m01_make: 견본 로직 줄 끝수 묶음(옛 /calc row) · check_logic 끝수 모양 검사 지움
- test_m01_cache: 목록 막힘 = 문서 막힘(master_doc_block.reasons) 전수 · 요소 지도 = 문서 막힘으로 같은 단언

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 15:15:49 +09:00
co-authored by Claude Opus 5.5
parent 2123d43773
commit 548fc3d00a
7 changed files with 144 additions and 1005 deletions
@@ -1,178 +0,0 @@
"""855 2-E1 — 서버에서 걷은 M01 옛 셈 길(`POST /api/m01/calc` · `/text` · `GET /logic/auto`)의 몸 — 시험 전용.
옛 엔진(`master_formula` · `master_text` · `master_sheet_line`)은 B09 · M02 가 아직 씀 →
그 엔진을 이 길 꼴로 보던 시험(test_m01_text · test_m01_api · test_m01_copy · test_794_1 · test_714_1)이
앱에 `router` 를 붙여 그대로 셈. 2-E4(엔진 지움)에서 같이 지움.
"""
from __future__ import annotations
from decimal import Decimal
from typing import Any
from fastapi import APIRouter
from pydantic import BaseModel
from M01_MasterData import M01_MasterData_Router as m01
from M01_MasterData import M01_MasterData_Store as store
import master_sheet_line as msl # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤
cm, mf = store.cm, store.cm.mf
DRAFT = "_초안.json"
router = APIRouter(prefix="/api/m01")
class CalcBody(BaseModel):
key: str
inputs: dict[str, Any] = {}
row: dict[str, Any] | None = None
file: str | None = None
고름: dict[str, str] = {}
def _swap(files: dict, key: str, row: dict, file: str | None) -> str:
"""저장 전 시험 — 메모리 사본에서 그 로직을 고친 줄로 바꿈(없으면 `file` 에 더함)."""
row = store._dec(row)
for data in files.values():
if data.get("그룹") != "로직":
continue
items = data.get("줄") or []
for i, old in enumerate(items):
if str(old.get("키")) == key:
items[i] = {**row, "키": key}
return key
if file is None:
file = DRAFT
files[file] = {"그룹": "로직", "원문": "자체", "줄": []}
if file not in files or files[file].get("그룹") != "로직":
raise store.StoreError(404, f"없는 로직 파일 「{file}」")
new = store.mk.table_id("로직", files[file].get("원문")) + "999999"
files[file].setdefault("줄", []).append({**row, "키": new})
return new
def _files(key: str, row: dict | None, file: str | None) -> tuple[dict, str]:
files = cm.load(folder=store.FOLDER)
if row is not None:
key = _swap(files, str(row.get("키") or key), row, file)
return files, key
_FAIL = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError)
def calc(key: str, inputs: dict, row: dict | None = None, file: str | None = None) -> dict:
given = {k: store._dec(v) for k, v in inputs.items()}
files, key = _files(key, row, file)
try:
given = mf.fill_empty(mf.Master(files).logic(key), given)
result = cm.calc(files, key, given)
except _FAIL as e:
return {"ok": False, "reason": str(e) or type(e).__name__}
if "결과" in result:
return {"ok": True, "result": result["결과"], "middle": result["중간"]}
sums = {k: result[k] for k in mf.BUNDLE}
return {"ok": True, "lines": result["줄"], "sums": sums, "middle": result["중간"]}
def text(key: str, inputs: dict, row: dict | None = None, file: str | None = None) -> dict:
"""읽는 식 줄(`master_text`) + 계산서 줄 덧칸(`master_sheet_line.annotate` · 714-1)."""
given = {k: store._dec(v) for k, v in inputs.items()}
files, key = _files(key, row, file)
try:
given = mf.fill_empty(mf.Master(files).logic(key), given)
got = store.mtx.lines(files, key, given)
except _FAIL as e:
return {"ok": False, "reason": str(e) or type(e).__name__}
if not isinstance(got, dict) or not got.get("ok"):
return got
try:
return msl.annotate(files, key, given, got)
except _FAIL:
return got
def auto(key: str) -> dict:
"""견본 입력 — 옛 자동값(`master_auto`) · 없는 로직 = 404."""
whole = store.loaded()[1]
try:
return {"값": store.mau.values(whole, whole.logic(key))}
except mf.FormulaError as e:
raise store.StoreError(404, str(e)) from e
@router.get("/logic/auto")
def get_logic_auto(key: str) -> dict:
return m01._call(auto, key)
@router.post("/calc")
def post_calc(body: CalcBody) -> dict:
with mf.mp.choosing(body.고름):
got = m01._call(calc, body.key, body.inputs, body.row, body.file)
if not got.get("lines"):
return got
whole = store.loaded()[1]
try:
logic = body.row or whole.logic(body.key)
except mf.FormulaError:
return got
lines = _pct_extras(whole, logic, got["lines"], got.get("middle") or {})
return {**got, "lines": m01._num(lines)}
@router.post("/text")
def post_text(body: CalcBody) -> dict:
with mf.mp.choosing(body.고름):
return m01._call(text, body.key, body.inputs, body.row, body.file)
COSTS = ("노무비", "재료비", "경비")
# ── 옛 % 덧줄 표기(옛 `M02_Labor_Doc.pct_extras` · 855-E 2-E4 에서 제품에서 걷어 옛 길 도우미로 옮김) ──
def _pct_extras(whole: Any, logic: dict, lines: list[dict], env: dict) -> list[dict]:
"""% 덧줄(149-4) — 덧줄 식이 「X * Y / 100」 이면 그 엔진 줄(호표 수 뒤 같은 차례)에 덧칸
`율` = Y(엔진 마지막 env 로 셈) · `규격` = X 이름(「노무비의 %」 · 인력 줄 합 「인건비의 %」 ·
`줄.'이름'` · 중간값 「이름의 %」 · 그 밖 복합 = 빈 글). 다른 덧줄 · 흐름 로직 · 못 셈 = 그대로."""
if isinstance(logic.get("흐름"), dict):
return lines
out, head = list(lines), len(logic.get("호표") or [])
for n, add in enumerate(logic.get("덧줄") or []):
if head + n >= len(out):
break
try:
node = mf.parse(add.get("식") or "")
except mf.FormulaError:
continue
if not (
node[0] == "bin"
and node[1] == "/"
and node[3] == ("num", Decimal(100))
and node[2][0] == "bin"
and node[2][1] == "*"
):
continue # 금액 식(기계손료 등) · 조건부 % = 「식」 그대로
base, part = node[2][2], node[2][3]
try:
rate = mf.evaluate(part, dict(env), whole)
except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError):
continue
if isinstance(rate, Decimal):
out[head + n] = {**out[head + n], "율": rate, "규격": _pct_base_name(base)}
return out
def _pct_base_name(node: tuple) -> str:
"""% 덧줄 밑수 이름 — B09 대가(`B09_Estimation_Labor_Source._base_of`)와 같은 말."""
if node[0] == "name":
return f"{node[1]}의 %" # 노무비 · 재료비 · 경비 · 중간값 이름
if node[0] == "field" and node[1] == ("name", "줄"):
return f"{node[2]}의 %"
parts = list(mf.walk(node))
if any(x[0] == "ref" and str(x[1]).startswith("LB") for x in parts) and not any(
x[0] == "name" and x[1] in COSTS for x in parts
):
return "인건비의 %"
return ""
+23 -62
View File
@@ -1,10 +1,12 @@
"""M01 마스터 데이터 API — 계약 `resources/master_data/_화면_계약.md`.
임시 폴더에 master_data 첫 층 JSON 사본을 두고 읽기 · 시험 계산 · 저장 · 409 · 422.
임시 폴더에 master_data 첫 층 JSON 사본을 두고 읽기 · 셈(수식 문서) · 저장 · 409 · 422.
옛 M01 `/calc` · `/text` 길(엔진 · 글자 수 받기 · 저장 전 로직 줄 시험계산)은 855-E 2-E4 에서 걷음.
"""
from __future__ import annotations
import importlib
import json
import shutil
from decimal import Decimal
@@ -17,7 +19,6 @@ from fastapi.testclient import TestClient
from M01_MasterData import M01_MasterData_Router as router_module
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
LABOR = "인력.json"
@@ -52,7 +53,6 @@ def client(tmp_path: Path, monkeypatch) -> TestClient:
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)
@@ -62,19 +62,16 @@ 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",
json={"key": LOGIC_KEY, "inputs": {**LOGIC_INPUTS, **inputs}},
def _calc(**inputs) -> dict:
"""문서 셈 — 지금 `store.FOLDER`(임시 사본) 색인 · 수식 문서."""
ml = store._docs().ml
docs = ml.load_all()
links = ml.Links(store.loaded()[1], docs)
got = importlib.import_module("master_doc_calc").calc(
docs[LOGIC_KEY], links, {**LOGIC_INPUTS, **inputs}
)
assert res.status_code == 200, res.text
return res.json()
assert got["셈됨"], got
return got
def _labor_row(client: TestClient, number: str) -> tuple[dict, str]:
@@ -168,21 +165,18 @@ def test_로직_목록_하나_시험계산(client: TestClient) -> None:
assert _get(client, "/api/m01/logics", blocked=1)["logics"] == []
one = _get(client, "/api/m01/logic", key=LOGIC_KEY)
assert one["file"] == "로직_건설품셈_03장_토공사.json" and one["blocked"] is False
got = _calc(client)
assert got["ok"] is True
lines = {x["이름"]: x for x in got["lines"]}
got = _calc()
lines = {x["이름"]: x for x in got["줄"]}
one = lines["화약취급공"] # 751-3 — 줄 0.1 원 · 비목 합 1 원 버림
raw = Decimal(str(one["수량"])) * Decimal(str(one["단가"]))
assert Decimal(str(one["금액"])) == Decimal(str(int(raw * 10))) / 10
gap = sum(x["금액"] for x in got["lines"]) - got["sums"]["계"]
assert -1e-6 <= gap < 3
stop = _calc(client, 없는입력=1)
assert stop["ok"] is False and "모르는 입력" in stop["reason"]
gap = sum(x["금액"] for x in got["줄"]) - got["계"]
assert 0 <= gap < 3
def test_저장_고침은_파일에_쓰고_낡은_판본은_409(client: TestClient) -> None:
row, version = _labor_row(client, "1016")
before = _calc(client)["sums"]["계"]
before = _calc()["계"]
edited = {**row, "값": row["값"] + 1000}
body = {
"files": [
@@ -198,7 +192,9 @@ def test_저장_고침은_파일에_쓰고_낡은_판본은_409(client: TestClie
new_version = res.json()["files"][0]["version"]
assert new_version != version
assert _labor_row(client, "1016") == (edited, new_version)
assert _calc(client)["sums"]["계"] == pytest.approx(before + 1000 * 0.04) # 화약취급공 0.040 인
assert _calc()["계"] == pytest.approx(
before + 1000 * Decimal("0.04"), abs=1
) # 화약취급공 0.040 인
data = json.loads((store.FOLDER / LABOR).read_text(encoding="utf-8"))
assert (
data["그룹"] == "인력"
@@ -262,34 +258,11 @@ def test_요소_찾기_기계는_구분_상세구분_실림(client: TestClient)
assert all(x["구분"] and x["상세구분"] for x in found["items"])
def test_단가_자동_요소_찾기_저장전_시험계산(client: TestClient) -> None:
one = _get(client, "/api/m01/logic", key=LOGIC_KEY)
def test_단가_자동_요소_찾기(client: TestClient) -> None:
found = _get(client, "/api/m01/elements", group="인력", q="보통인부")
assert key_of("LB:1002") in [x["ref"] for x in found["items"]]
tables = _get(client, "/api/m01/elements", group="소요량", q="암발파", limit=5)
assert tables["items"] and all(x["값칸"] for x in tables["items"])
raw = (store.FOLDER / one["file"]).read_bytes()
before = _calc(client)["sums"]["계"]
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},
)
lines = res.json()["lines"]
names = [x["이름"] for x in lines] # 소모자재 덧줄(3-3-6 주⑨)은 남음
assert (
names[0] == "화약취급공" and "보통인부" not in names and res.json()["sums"]["계"] < before
)
new = {**half, "키": "", "원문번호": "새 로직"}
body = {
"key": "",
"inputs": LOGIC_INPUTS,
"row": new,
"file": one["file"],
}
assert client.post("/api/m01/calc", json=body).json()["ok"] is True
assert (store.FOLDER / one["file"]).read_bytes() == raw # 시험 계산은 안 씀
def test_쓰기_모양은_읽은_값과_같음() -> None:
@@ -304,18 +277,6 @@ def test_쓰기_모양은_읽은_값과_같음() -> None:
assert "\r" not in text and text.endswith("}\n")
def test_시험계산_글로_온_수도_받음(client: TestClient) -> None:
def calc(**inputs):
body = {"key": key_of("GF000219"), "inputs": inputs}
return client.post("/api/m01/calc", json=body).json()
base = {"돌": "견치돌", "쌓기": "골쌓기", "높이": 1, "초과증가율": 80}
assert calc(뒷길이=35, **base)["sums"]["계"] == pytest.approx(203281.2)
as_text = calc(**{**base, "뒷길이": "35", "높이": "1"})
assert as_text["ok"] is True and as_text["sums"]["계"] == pytest.approx(203281.2)
assert "고르기 밖" in calc(뒷길이="36", **base)["reason"]
def test_저장은_고친_줄만_바꿈(client: TestClient) -> None:
old = (store.FOLDER / LABOR).read_text(encoding="utf-8").split("\n")
row, version = _labor_row(client, "1016")
@@ -381,9 +342,9 @@ def test_구분_목록(client: TestClient) -> None:
def test_전력은_계약종별을_골라야_값이_섬(client: TestClient) -> None:
"""후보 조건 「계약종별: 입력」(PLAN 7-4b 뒤 절반 — 품셈재료 간접 없이 호표에 바로 박음) —
계산은 로직 입력으로 값이 섬(mf.element 로 직접 확인)."""
one = _get(client, "/api/m01/logic", key=key_of("GC000893"))
one = _get(client, "/api/m01/logic", key="GC000893")
cond = {"이름": "전력량요금", "계약종별": "입력"}
assert "전력 계약종별" in {x["이름"] for x in _row(one["file"], one["logic"]["키"])["입력"]}
assert "전력 계약종별" in {v["열쇠"] for v in store._docs().docs()[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, {"전력 계약종별": "주택용 저압"})
+56 -69
View File
@@ -1,110 +1,100 @@
"""M01 견본 입력(`GET /logic/auto`) · 값 빈 품목은 그 줄만 비움 — PLAN 3-2 · 계약 3-1 표.
"""M01 견본 입력(자동값) · 값 빈 품목은 그 줄만 비움 — PLAN 3-2 · 계약 3-1 표.
자동값 = 고르기 목록 첫째 · 범위 최솟값 · 찾기 조건 값은 그 표 가장 낮은 줄 · 나누는 수 1 · 그 밖 0.
정본 폴더를 읽기만 함(쓰지 않음).
자동값 = 문서 자동값(`M02_Doc_Copy.auto_of` · 옛 `master_auto` 와 같음) · 셈 = 수식 문서 셈(옛 M01
`/logic/auto` · `/calc` 길과 엔진은 855-E 2-E4 에서 걷음). 정본 폴더를 읽기만 함(쓰지 않음).
"""
from __future__ import annotations
from decimal import Decimal
import helper_855_engine as h
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from M01_MasterData import M01_MasterData_Router as router_module
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
from M02_MasterTemplete import M02_Doc_Copy as dc
from resources.tester.helper_855_line import run_line
@pytest.fixture(scope="module")
def client() -> TestClient:
app = FastAPI()
app.include_router(router_module.router)
app.include_router(old_engine.router)
return TestClient(app)
def _auto(key: str) -> dict:
whole = h.world()[0]
return dc.auto_of(dc.doc_of(whole, key), whole)
def _auto(client: TestClient, key: str) -> dict:
got = client.get("/api/m01/logic/auto", params={"key": key})
assert got.status_code == 200, got.text
return got.json()["값"]
def _calc(client: TestClient, key: str) -> dict:
got = client.post("/api/m01/calc", json={"key": key, "inputs": _auto(client, key)}).json()
assert got["ok"] is True, got
def _calc(key: str, given: dict | None = None) -> dict:
got = h.traced(key, _auto(key) if given is None else given)
assert got["셈됨"], got
return got
def test_고르기는_목록_첫째_범위는_최솟값(client) -> None:
got = _auto(client, "GF000160") # 12-4 합판거푸집
def test_고르기는_목록_첫째_범위는_최솟값() -> None:
got = _auto("GF000160") # 12-4 합판거푸집
assert got["횟수"] == "1회사용시" and got["폼타이"] == "아님"
assert "합판" not in got # 재료 입력 키 목록은 걷음 — 품목은 기본 검색어(PLAN 8-3)
assert got["소형할증"] == 0 # 범위 [0, 30]
assert got["높이할증"] == 0 # 찾기·나누기에 안 쓰임
def test_찾기_조건_값은_표_가장_낮은_줄(client) -> None:
assert _auto(client, "GC000561")["층수층"] == 0 # 가장 낮은 줄 「6 미만」 — 아래 끝이 열림
assert _auto(client, "GC000559")["강재총사용량"] == 0 # 「60 미만」
def test_찾기_조건_값은_표_가장_낮은_줄() -> None:
assert _auto("GC000561")["층수층"] == 0 # 가장 낮은 줄 「6 미만」 — 아래 끝이 열림
assert _auto("GC000559")["강재총사용량"] == 0 # 「60 미만」
# 두 표가 같은 입력을 씀 — 한 표는 6 부터 · 한 표는 15 부터 → 둘 다에 드는 가장 낮은 값
assert _auto(client, "GC000724")["규격"] == 15
assert _auto("GC000724")["규격"] == 15
def test_나누는_수는_1(client) -> None:
assert _auto(client, "GC000998")["수직고초과단계"] == 1
assert _auto(client, "GC000278")["두께"] == 1
def test_나누는_수는_1() -> None:
assert _auto("GC000998")["수직고초과단계"] == 1
assert _auto("GC000278")["두께"] == 1
def test_없는_로직은_404(client) -> None:
assert client.get("/api/m01/logic/auto", params={"key": "GF999999"}).status_code == 404
def test_없는_로직은_문서_없음() -> None:
assert dc.doc_of(h.world()[0], "GF999999") is None
def test_견본_금액은_앞과_같음(client) -> None:
def test_견본_금액은_앞과_같음() -> None:
# 751-3 끝수(줄 0.1 원 · 비목 합 1 원 버림) — 옛 날 값 117,485.212 · 79,279.668
assert Decimal(str(_calc(client, "GF000160")["sums"]["계"])) == Decimal("117484")
assert Decimal(str(_calc(client, "GF000219")["sums"]["계"])) == Decimal("79279")
assert Decimal(str(_calc("GF000160")["계"])) == Decimal("117484")
assert Decimal(str(_calc("GF000219")["계"])) == Decimal("79279")
def test_빈_줄을_부르는_덧줄도_비움(client) -> None:
got = _calc(client, "GF000185") # 레미콘 후보 0 → 레미콘 금액을 부르는 덧줄
blank = [one for one in got["lines"] if one.get("까닭")]
def test_빈_줄을_부르는_덧줄도_비움() -> None:
got = _calc("GF000185") # 레미콘 후보 0 → 레미콘 금액을 부르는 덧줄
blank = [one for one in got["줄"] if one.get("까닭")]
assert [one["이름"] for one in blank] == ["구체콘크리트(철근) 레미콘", "콘크리트다짐"]
assert "구체콘크리트(철근) 레미콘" in blank[1]["까닭"] and blank[1]["금액"] is None
assert (
blank[1]["까닭"] == blank[0]["까닭"] and blank[1]["금액"] is None
) # 문서 = 빈 까닭 그대로
def test_원_단위_입력은_자동값_null(client) -> None:
got = _auto(client, "GF000051") # 예취기가격(원)
def test_원_단위_입력은_자동값_null() -> None:
got = _auto("GF000051") # 예취기가격(원)
assert got["예취기가격"] is None
assert got["조림목본수"] == 0 # 원 아닌 수는 그대로 0
def test_빈_입력을_쓰는_줄만_비움(client) -> None:
got = _calc(client, "GF000051")
blank = {one["이름"]: one for one in got["lines"] if one.get("까닭")}
def test_빈_입력을_쓰는_줄만_비움() -> None:
got = _calc("GF000051")
blank = {one["이름"]: one for one in got["줄"] if one.get("까닭")}
assert set(blank) == {"예취기 손료"}
for one in blank.values():
assert one["단가"] is None and one["금액"] is None and "비어 있음" in one["까닭"]
rest = sum(Decimal(str(one["금액"])) for one in got["lines"] if one["금액"] is not None)
gap = rest - Decimal(str(got["sums"]["계"])) # 빈 줄은 빼고 더함 · 비목마다 1 원 버림(751-3)
rest = sum(Decimal(str(one["금액"])) for one in got["줄"] if one["금액"] is not None)
gap = rest - Decimal(str(got["계"])) # 빈 줄은 빼고 더함 · 비목마다 1 원 버림(751-3)
assert rest > 0 and 0 <= gap < 3
assert got["sums"]["경비"] == 0
assert got["경비"] == 0
def test_빠진_원_입력도_null_처럼_줄만_비움(client) -> None:
given = {k: v for k, v in _auto(client, "GF000051").items() if k != "예취기가격"}
for path in ("calc", "text"):
got = client.post(f"/api/m01/{path}", json={"key": "GF000051", "inputs": given}).json()
assert got["ok"] is True, (path, got)
lines = client.post("/api/m01/calc", json={"key": "GF000051", "inputs": given}).json()["lines"]
def test_빠진_원_입력도_null_처럼_줄만_비움() -> None:
given = {k: v for k, v in _auto("GF000051").items() if k != "예취기가격"}
lines = _calc("GF000051", given)["줄"]
assert {o["이름"] for o in lines if o.get("까닭")} == {"예취기 손료"}
@pytest.mark.parametrize("key", ["GF000002", "GF000056", "GF000076"])
def test_체인톱_가격_오일은_자재품목(client, key) -> None:
def test_체인톱_가격_오일은_자재품목(key) -> None:
"""44-5 — 체인톱 가격 = 「동력체인톱」(기본 첫 규격) · 체인오일 = 「작동유」 · 손 입력 없음."""
assert not {"체인톱가격", "체인오일단가"} & set(_auto(client, key))
lines = {o["이름"]: o for o in _calc(client, key)["lines"]}
assert not {"체인톱가격", "체인오일단가"} & set(_auto(key))
lines = {o["이름"]: o for o in _calc(key)["줄"]}
assert lines["체인톱 손료"]["품목"]["키"] == "MT016587" # 400mm · 530,000원
assert lines["체인톱 손료"]["단가"] == 530000 and "경비" in lines["체인톱 손료"]["비목"]
assert lines["체인오일"]["품목"]["키"] == "MT000583" # 기어작동유 · 4,612원/ℓ
@@ -115,22 +105,19 @@ def test_체인톱_가격_오일은_자재품목(client, key) -> None:
) # 잡품 = 휘발유값 40% 그대로(0.1 원 버림 · 751-3)
def test_체인톱_규격은_고를_수_있음(client) -> None:
given = _auto(client, "GF000056")
body = {"key": "GF000056", "inputs": given, "고름": {"4": "MT016588"}} # 4 = 체인톱 손료 줄
got = client.post("/api/m01/calc", json=body).json()
saw = next(o for o in got["lines"] if o["이름"] == "체인톱 손료")
assert saw["품목"]["키"] == "MT016588" and saw["단가"] == 900000
def test_체인톱_규격은_고를_수_있음() -> None:
got = run_line(h.world()[0], "GF000056", {}, None, {"4": "MT016588"}) # 4 = 체인톱 손료 줄
saw = next(o for o in got["재료"] if o["이름"] == "체인톱 손료")
assert saw["단가"] == 900000
def test_표_찾기_실패는_그_줄만_비우고_까닭은_날글_없이(client) -> None:
given = {**_auto(client, "GC001000"), "시공구분": "기계시공"} # 표 1-2-3 에 그 조합 줄이 없음
got = client.post("/api/m01/calc", json={"key": "GC001000", "inputs": given}).json()
assert got["ok"] is True, got
blank = [one for one in got["lines"] if one.get("까닭")]
def test_표_찾기_실패는_그_줄만_비우고_까닭은_날글_없이() -> None:
given = {**_auto("GC001000"), "시공구분": "기계시공"} # 표 1-2-3 에 그 조합 줄이 없음
got = _calc("GC001000", given)
blank = [one for one in got["줄"] if one.get("까닭")]
assert blank and all(one["금액"] is None for one in blank)
why = blank[0]["까닭"]
assert "표 QC001869(1-2-3)에 시공구분 기계시공" in why and "인 줄이 없음" in why
assert not any(ch in why for ch in "{}'") and "Decimal" not in why
rest = sum(Decimal(str(one["금액"])) for one in got["lines"] if one["금액"] is not None)
assert Decimal(str(got["sums"]["계"])) == rest
rest = sum(Decimal(str(one["금액"])) for one in got["줄"] if one["금액"] is not None)
assert Decimal(str(got["계"])) <= rest < Decimal(str(got["계"])) + 3 # 비목마다 1 원 버림
+16 -17
View File
@@ -40,6 +40,12 @@ def client(tmp_path: Path, monkeypatch) -> TestClient:
return TestClient(app)
def _mb():
import importlib
return importlib.import_module("master_doc_block")
def _logics(client: TestClient, **params) -> list[dict]:
res = client.get("/api/m01/logics", params=params)
assert res.status_code == 200, res.text
@@ -56,15 +62,12 @@ def _write(file: str, change) -> None:
def test_세어_둔_막힘이_줄마다_검사한_것과_같다(client: TestClient) -> None:
listed = _logics(client)
files, whole = store.loaded()
rows = {
str(r.get("키")): r for _, d in files.items() if d.get("그룹") == "로직" for r in d["줄"]
}
for key in parts.parts(): # 부품 문서(813-2)는 목록에서 뺌 — 키로 열기 · 셈은 그대로
rows.pop(key, None)
assert len(listed) == len(rows)
_, whole = store.loaded()
docs = store._docs().docs() # 막힘 = 수식 문서 기준(master_doc_block · 855 2-B3)
keys = {k for k in docs if k not in parts.parts()} # 부품 문서(813-2)는 목록에서 뺌
assert {x["키"] for x in listed} == keys
for one in listed:
reasons = store.cm.mf.check_logic(whole, rows[one["키"]])[0]
reasons = _mb().reasons(one["키"], docs[one["키"]], docs, whole)
assert one["reasons"] == reasons and one["blocked"] is bool(reasons)
@@ -176,13 +179,11 @@ def test_요소를_고쳐_저장해도_막힘_표시가_전수와_같다(client:
res = _save_file(client, "인력.json", [{"op": "edit", "key": "LB000014", "row": row}])
assert res.status_code == 200, res.text
listed = _logics(client)
files, whole = store.loaded()
rows = {
str(r.get("키")): r for _, d in files.items() if d.get("그룹") == "로직" for r in d["줄"]
}
_, whole = store.loaded()
docs = store._docs().docs()
assert [x["키"] for x in listed] == [x["키"] for x in was]
for one in listed:
assert one["reasons"] == store.cm.mf.check_logic(whole, rows[one["키"]])[0]
assert one["reasons"] == _mb().reasons(one["키"], docs[one["키"]], docs, whole)
def test_요소_지도가_전수_검사와_같다(client: TestClient) -> None:
@@ -199,8 +200,6 @@ def test_요소_지도가_전수_검사와_같다(client: TestClient) -> None:
marked = {key for key, got in counts.items() if got[2] & marks}
empty = {**files, "인력.json": {**files["인력.json"], "줄": []}}
other = store.cm.mf.Master(empty)
rows = {
str(r.get("키")): r for _, d in files.items() if d.get("그룹") == "로직" for r in d["줄"]
}
changed = {k for k, r in rows.items() if store.cm.mf.check_logic(other, r)[0] != counts[k][0]}
docs = store._docs().docs()
changed = {k for k, d in docs.items() if _mb().reasons(k, d, docs, other) != counts[k][0]}
assert changed and changed <= marked
-27
View File
@@ -6,7 +6,6 @@
from __future__ import annotations
import shutil
from decimal import Decimal
from pathlib import Path
import pytest
@@ -16,7 +15,6 @@ from fastapi.testclient import TestClient
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
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
from M01_MasterData import M01_MasterData_Store_Make as make
REAL = store.FOLDER
@@ -38,7 +36,6 @@ def client(tmp_path: Path, monkeypatch) -> TestClient:
doc_store._memo.clear()
app = FastAPI()
app.include_router(router_module.router)
app.include_router(old_engine.router)
return TestClient(app)
@@ -91,30 +88,6 @@ def _own_save(client: TestClient, change: dict, version: str, want: int = 200) -
# ── 끝수 ──────────────────────────────────────────────────────────────
def test_끝수_묶음이_계에_붙고_글자는_안_붙는다(client: TestClient) -> None:
plain = _post(client, "/api/m01/calc", {"key": "", "inputs": {}, "row": _draft()})
assert plain["ok"] is True, plain
raw = Decimal(str(plain["sums"]["계"]))
assert raw == 24581 # 172068 / 7 = 24,581.14 → 줄 0.1 원 · 소계 1 원 버림(751-3 · 품셈 1-2-2)
cut = _post(
client,
"/api/m01/calc",
{"key": "", "inputs": {}, "row": _draft({"대상": "계", "자리": -1, "방법": "올림"})},
)
assert Decimal(str(cut["sums"]["계"])) == 24590 # 로직 끝수 묶음 = 1-2-2 버림 뒤 한 번 더
assert cut["sums"]["노무비"] == cut["sums"]["계"] # 비목 합마다 끊고 계 = 그 합
text = _post(client, "/api/m01/calc", {"key": "", "inputs": {}, "row": _draft("원 미만 버림")})
assert Decimal(str(text["sums"]["계"])) == raw # 글자 끝수는 설명일 뿐
def test_끝수_묶음_모양을_검사가_잡는다() -> None:
bad = {"키": "GX000001", "원문번호": "", "호표": [], "끝수": {"대상": "줄", "방법": "내림"}}
found = store.cm.mf.check_logic(store.cm.master(REAL), bad)[0]
assert any("대상" in x for x in found) and any("방법" in x for x in found)
# ── 절 거르기 ─────────────────────────────────────────────────────────
def test_절로_표_거르기(client: TestClient) -> None:
hits = _get(client, "/api/m01/tables", group="소요량", section="13-4", size=500)["tables"]
+49 -83
View File
@@ -1,19 +1,21 @@
"""M01 재료 기본 검색어 · 고름 · 단위 환산 · 단위 경고 — PLAN 8-1 · 8-2 계약.
검색어 든 견본 로직 줄을 시험 안에서 만들어(`POST /calc` 의 `row` — 저장 안 함) 돌림. 정본 폴더는 읽기만.
재료 줄 단가 = `master_pick.priced`(문서 셈 · M02 가 같이 씀) · 기계 입력 · 품목 칸 = 수식 문서 셈.
옛 M01 `/calc` 길(견본 로직 줄 `row`)과 엔진은 855-E 2-E4 에서 걷음. 정본 폴더는 읽기만.
"""
from __future__ import annotations
from decimal import Decimal
import helper_855_engine as h
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
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
from M02_MasterTemplete import M02_Doc_Copy as dc
mf = store.cm.mf
mp = mf.mp
@@ -23,84 +25,62 @@ mp = mf.mp
def client() -> TestClient:
app = FastAPI()
app.include_router(router_module.router)
app.include_router(old_engine.router)
return TestClient(app)
def _sample(term: str, unit: str, **cond) -> dict:
"""재료 줄 하나짜리 견본 로직 — 검색어 줄 하나 · 수량 1."""
return {
"이름": "검색어 견본",
"구분": "자체",
"입력": [],
"호표": [
{
"종류": "재료",
"요소": {"검색어": term, **cond},
"이름": "견본 재료",
"단위": unit,
"수량": "1",
"비목": "재료비",
}
],
}
def _line(term: str, unit: str, picks: dict | None = None) -> dict:
"""검색어 재료 줄 하나(수량 1) — {단가, 출처, 까닭, 단위경고?, 품목?}."""
token = mp.CHOSEN.set(picks or {})
try:
price, source, why, extra = mp.priced(
store.loaded()[1], {"단위": unit}, {"검색어": term}, {}, 0
)
finally:
mp.CHOSEN.reset(token)
return {"단가": price, "출처": source or "", "까닭": why, **extra}
def _line(client: TestClient, row: dict, picks: dict | None = None, path: str = "calc") -> dict:
body = {"key": "GF999999", "inputs": {}, "row": row, **({"고름": picks} if picks else {})}
got = client.post(f"/api/m01/{path}", json=body).json()
assert got.get("ok", True) is True, got
return got["lines"][0] if path == "calc" else got
def _auto(key: str) -> dict:
whole = h.world()[0]
return dc.auto_of(dc.doc_of(whole, key), whole)
def test_검색어로_찾고_지역_낱말이_맞는_줄이_먼저(client) -> None:
seoul = _line(client, _sample("합판(내수) 12t 서울", "㎡"))
def test_검색어로_찾고_지역_낱말이_맞는_줄이_먼저() -> None:
seoul = _line("합판(내수) 12t 서울", "㎡")
assert seoul["출처"].startswith("MT000018") and seoul["단가"] == 11354 # 값 열 가운데 낮은 값
busan = _line(client, _sample("합판(내수) 12t 부산", "㎡"))
busan = _line("합판(내수) 12t 부산", "㎡")
assert busan["출처"].startswith("MT000020") and busan["단가"] == 11488
assert "단위경고" not in seoul
def test_고름은_그_줄만_그_품목으로_셈(client) -> None:
row = _sample("합판(내수) 12t 서울", "㎡")
got = _line(client, row, {"0": "MT000019"})
def test_고름은_그_줄만_그_품목으로_셈() -> None:
got = _line("합판(내수) 12t 서울", "㎡", {"0": "MT000019"})
assert got["출처"].startswith("MT000019") and got["단가"] == 11556
assert _line(client, row)["단가"] == 11354 # 요청마다 — 저장 안 함
text = _line(client, row, {"0": "MT000019"}, "text")
assert text["ok"] is True # 읽는 식도 같은 몸으로 돎
assert _line("합판(내수) 12t 서울", "㎡")["단가"] == 11354 # 요청마다 — 저장 안 함
def test_같은_성격_단위는_줄_단위로_환산(client) -> None:
got = _line(client, _sample("어닐링철선 서울 4.0mm", "톤")) # 자재 kg → 줄 톤
def test_같은_성격_단위는_줄_단위로_환산() -> None:
got = _line("어닐링철선 서울 4.0mm", "톤") # 자재 kg → 줄 톤
assert got["단가"] == 1610000 and "단위경고" not in got
got = _line(client, _sample("어닐링철선 서울 4.0mm", "g"))
assert got["단가"] == pytest.approx(1.61)
got = _line("어닐링철선 서울 4.0mm", "g")
assert got["단가"] == pytest.approx(Decimal("1.61"))
def test_성격이_다르면_계산은_하고_단위경고(client) -> None:
got = _line(client, _sample("어닐링철선 서울 4.0mm", "m"))
def test_성격이_다르면_계산은_하고_단위경고() -> None:
got = _line("어닐링철선 서울 4.0mm", "m")
assert got["단가"] == 1610 and got["단위경고"] == "줄 m · 자재 kg"
assert got["금액"] == 1610
def test_검색어_후보가_없으면_그_줄만_비움(client) -> None:
got = client.post(
"/api/m01/calc", json={"key": "GF999999", "inputs": {}, "row": _sample("없는물건zzz", "개")}
).json()
assert got["ok"] is True and got["lines"][0]["금액"] is None
assert "후보 없음" in got["lines"][0]["까닭"]
def test_검색어_후보가_없으면_그_줄만_비움() -> None:
got = _line("없는물건zzz", "개")
assert got["단가"] is None and "후보 없음" in got["까닭"]
def test_기계_입력은_목록_밖_원문번호도_받음(client) -> None:
def test_기계_입력은_목록_밖_원문번호도_받음() -> None:
key = "GC000267"
inputs = {
**old_engine.auto(key)["값"],
"기계": "0101-0007",
} # 고르기 목록 밖 · 기계 마스터엔 있음
got = client.post("/api/m01/calc", json={"key": key, "inputs": inputs}).json()
assert got["ok"] is True, got
bad = client.post("/api/m01/calc", json={"key": key, "inputs": {**inputs, "기계": "9999-9999"}})
assert bad.json()["ok"] is False # 기계 마스터에 없는 번호는 그대로 막힘
inputs = {**_auto(key), "기계": "0101-0007"} # 고르기 목록 밖 · 기계 마스터엔 있음
assert h.calc(key, inputs)["셈됨"]
assert not h.calc(key, {**inputs, "기계": "9999-9999"})["셈됨"] # 마스터에 없는 번호 = 막힘
def test_단위_환산_표() -> None:
@@ -111,7 +91,7 @@ def test_단위_환산_표() -> None:
assert mp.same_kind("ℓ", "㎥") and not mp.same_kind("kg", "m")
def test_check_master_검색어_후보0_단위경고(client) -> None:
def test_check_master_검색어_후보0_단위경고() -> None:
whole = store.loaded()[1]
assert mf.check_pick(whole, "줄", {"검색어": "합판(내수) 12t 서울"}) == []
assert "후보 0" in mf.check_pick(whole, "줄", {"검색어": "없는물건zzz"})[0]
@@ -119,37 +99,23 @@ def test_check_master_검색어_후보0_단위경고(client) -> None:
assert "성격이 다름" in mf.check_unit(whole, "줄", {"검색어": "어닐링철선 서울 4.0mm"}, "m")[0]
def test_기계_입력은_EQ_키도_원문번호로_풀어_받음(client) -> None:
def test_기계_입력은_EQ_키도_원문번호로_풀어_받음() -> None:
key = "GC000267"
number = "0101-0007" # 고르기 목록 밖
eq = next(k for k, r in store.loaded()[1].index["EQ"].items() if r.get("원문번호") == number)
base = {**old_engine.auto(key)["값"]}
by_number = client.post(
"/api/m01/calc", json={"key": key, "inputs": {**base, "기계": number}}
).json()
by_key = client.post("/api/m01/calc", json={"key": key, "inputs": {**base, "기계": eq}}).json()
assert by_key["ok"] is True, by_key
assert by_key["sums"] == by_number["sums"] # EQ 키 = 원문번호와 같은 계산
bad = client.post("/api/m01/calc", json={"key": key, "inputs": {**base, "기계": "EQ999999"}})
assert bad.json()["ok"] is False
base = _auto(key)
by_number = h.calc(key, {**base, "기계": number})
by_key = h.calc(key, {**base, "기계": eq})
assert by_key["셈됨"], by_key
assert [by_key[k] for k in h.KEYS] == [by_number[k] for k in h.KEYS] # EQ 키 = 원문번호
assert not h.calc(key, {**base, "기계": "EQ999999"})["셈됨"]
def test_재료_줄마다_품목_칸(client) -> None:
key = "GF000160"
body = {"key": key, "inputs": {k: str(v) for k, v in old_engine.auto(key)["값"].items()}}
lines = client.post("/api/m01/calc", json=body).json()["lines"]
idx = next(
i for i, x in enumerate(lines) if x.get("품목", {}).get("이름", "").startswith("합판(내수)")
)
first = lines[idx]["품목"]
assert (first["이름"], first["지역"]) == ("합판(내수)", "서울") and first[
"값칸"
] # 830-10 지역 칸
assert {"키", "이름", "규격", "단위", "값칸"} <= set(first)
lines = client.post("/api/m01/calc", json={**body, "고름": {str(idx): "MT000019"}}).json()[
"lines"
]
assert lines[idx]["품목"]["키"] == "MT000019" and "인천" in lines[idx]["품목"]["지역"]
def test_재료_줄마다_품목_칸() -> None:
got = h.traced("GF000160")
first = next(x["품목"] for x in got["줄"] if (x.get("품목") or {}).get("이름") == "합판(내수)")
assert mf.mp.mm.mmerge.where(first) == "서울" and first["키"].startswith("MT") # 830-10 지역 칸
assert {"키", "이름", "규격", "단위"} <= set(first)
def test_목록_검색은_띄어쓰기를_무시(client) -> None:
-569
View File
@@ -1,569 +0,0 @@
"""M01 읽는 식 줄(`POST /text`) — 계약 `resources/master_data/_화면_계약.md` 3장.
견본 셋: 산림 13-4-1 메쌓기 · 12-4 합판거푸집 · 12-17-1 펌프카 타설.
「모든 로직을 돌려도 멈추지 않는다」 둘 = 기본 로직 키 차례 고르게 400 · 전수 = `AISLO_TEST_ALL=1`.
"""
from __future__ import annotations
import json
import re
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_text as mt # noqa: E402
from helper_test_all import spread # 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 합판거푸집 — 재료 여럿 · 수량 0 줄
PUMP = "GF000182" # 12-17-1 펌프카 타설 — 하위 로직이 세 비목에 걸리고 덧줄이 있음
IDLE = "GC000999" # 일반전정 — 세 비목에 걸린 장비 줄이 수량 0 이라 몫이 모두 0
@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)
app = FastAPI()
app.include_router(router_module.router)
app.include_router(old_engine.router)
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)
return {k: str(v) for k, v in store.cm.시험입력(row).items()}
def _both(client: TestClient, key: str) -> tuple[dict, dict]:
body = {"key": key, "inputs": _inputs(key)}
text = client.post("/api/m01/text", json=body)
calc = client.post("/api/m01/calc", json=body)
assert text.status_code == 200 and calc.status_code == 200, text.text
return text.json(), calc.json()
def _all_lines(got: dict) -> list[dict]:
return [one for group in got["groups"] for one in group["줄"]]
def test_자릿수는_화면과_같다() -> None:
assert mt.fmt(Decimal("31500")) == "31,500"
assert mt.fmt(Decimal("2803.50")) == "2,803.5"
assert mt.fmt(Decimal("1") / Decimal(3)) == "0.3333"
assert mt.fmt(Decimal("-1234.5")) == "-1,234.5"
def test_메쌓기_줄은_수로만_적히고_계가_시험계산과_같다(client: TestClient) -> None:
got, calc = _both(client, STACK)
assert got["ok"] is True and Decimal(str(got["계"])) == Decimal(str(calc["sums"]["계"]))
rows = _all_lines(got)
assert [one["이름"] for one in rows] == ["석공", "보통인부"]
for one in rows:
assert "찾기(" not in one["글"] and "만약(" not in one["글"] and "로직(" not in one["글"]
assert one["글"].count("=") == 1 and " * " in one["글"]
assert "%" in rows[0]["글"] # 증가율은 따로 줄이 아니라 이 줄의 식에 녹아 있음
assert rows[0]["글"].startswith("268,908 * ")
def test_합판거푸집은_비목마다_묶이고_안_쓰는_줄에_까닭이_있다(client: TestClient) -> None:
got, calc = _both(client, FORM)
assert [g["비목"] for g in got["groups"]] == ["노무비", "재료비"]
for group in got["groups"]:
assert Decimal(str(group["소계"])) == Decimal(str(calc["sums"][group["비목"]]))
lines = sum(
Decimal(str(one["금액"])) for one in group["줄"]
) # 751-3 소계 = 줄 합 1 원 버림
assert 0 <= lines - Decimal(str(group["소계"])) < 1
why = [one for one in _all_lines(got) if one.get("까닭")]
assert why and all("0" in one["까닭"] for one in why)
def test_펌프카는_하위로직이_비목마다_한_줄씩이고_덧줄이_섞인다(client: TestClient) -> None:
got, calc = _both(client, PUMP)
assert [g["비목"] for g in got["groups"]] == ["노무비", "재료비", "경비"]
assert Decimal(str(got["계"])) == Decimal(str(calc["sums"]["계"]))
pump = [one for one in _all_lines(got) if one["이름"] == "콘크리트펌프차"]
assert len(pump) == 3 # 노무비 · 재료비 · 경비 몫이 따로
extra = next(one for one in _all_lines(got) if one["이름"].startswith("공구손료"))
assert (
extra["글"].endswith(f"= {mt.fmt_line_money(Decimal(str(extra['금액'])))}")
and "%" in extra["글"]
)
def test_몫이_모두_0인_장비_줄도_글에_남는다(client: TestClient) -> None:
got, calc = _both(client, IDLE)
idle = [one for one in _all_lines(got) if one["이름"] == "고소작업차"]
assert len(idle) == 1 # 비목 셋 몫이 다 0 이라도 줄이 사라지지 않음
assert Decimal(str(idle[0]["금액"])) == 0 and "수량 0" in idle[0]["까닭"]
assert idle[0]["글"].endswith(" * 0 = 0")
for group in got["groups"]:
assert Decimal(str(group["소계"])) == Decimal(str(calc["sums"][group["비목"]]))
def test_이름_꼴_식이_값_꼴과_짝이_된다(client: TestClient) -> None:
"""왼쪽 칸(이름 꼴)과 오른쪽 칸(값 꼴)이 같은 개수·같은 차례 · 짝 번호는 1 부터."""
for key in (STACK, PUMP, FORM):
got, _ = _both(client, key)
rows = _all_lines(got)
assert [one["짝"] for one in rows] == list(range(1, len(rows) + 1))
for one in rows:
assert one["이름글"].count(" = ") == 1
assert not any(x in one["이름글"] for x in ("찾기(", "로직(", "만약("))
def test_이름_꼴_식은_요소_이름과_별칭으로_적힌다(client: TestClient) -> None:
"""13-4-1 석공 줄 — 「석공노임 * 메쌓기인력.석공 * (1 + 증가율 %) = 석공비」."""
got, _ = _both(client, STACK)
mason = _all_lines(got)[0]
table = next(one for one in got["별칭"] if one["참조"] == "QF000421")
assert mason["이름글"] == f"석공노임 * {table['이름']}.석공 * (1 + 증가율 %) = 석공비"
assert mason["글"].startswith("268,908 * ") # 같은 줄의 값 꼴
pump, _ = _both(client, PUMP)
lines = _all_lines(pump)
split = [one for one in lines if one["이름"] == "콘크리트펌프차"]
assert [one["이름글"].split(" = ")[-1] for one in split] == [
"콘크리트펌프차노무비",
"콘크리트펌프차재료비",
"콘크리트펌프차경비",
]
extra = next(one for one in lines if one["이름"].startswith("공구손료"))
assert extra["이름글"] == "노무비 * 5 % = 공구손료및경장비"
def test_입력_없어도_이름_식은_보임(client: TestClient) -> None:
"""값을 고르기 전(PLAN 2-5) — 멈추지 않고 왼쪽 이름 식은 그대로, 글·금액만 빔."""
got = client.post("/api/m01/text", json={"key": STACK, "inputs": {}}).json()
assert got["ok"] is True
one = got["groups"][0]["줄"][0]
assert one["이름글"] and "석공노임" in one["이름글"]
assert one["글"] == "" and one["금액"] is None
def test_고른_값이_틀리면_그대로_막힘(client: TestClient) -> None:
"""값을 넣었는데 틀린 경우(고르기 밖)는 지금처럼 멈춤 — 안 고른 것과 다름."""
bad = dict(_inputs(STACK), 뒷길이=999)
got = client.post("/api/m01/text", json={"key": STACK, "inputs": bad}).json()
assert got["ok"] is False and "고르기" in got["reason"]
def test_끝수는_줄이_아니라_소계에_붙는다(client: TestClient) -> None:
got = client.get("/api/m01/logic", params={"key": STACK}).json()
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
group = cut["groups"][0]
assert group["끝수"] == "원 미만 버림"
assert Decimal(str(group["소계"])) == Decimal(str(group["소계"])).to_integral_value()
assert not any("버림" in one["글"] for one in group["줄"])
def test_이름_꼴_찾기_별칭은_표_열쇠_대신_짧은_표_제목(client: TestClient) -> None:
"""GC001008 덧줄 — 긴 표 제목(잔디깎기 공구손료·경장비 기계경비 요율)은 첫 + 끝 낱말."""
got, _ = _both(client, "GC001008")
extra = next(one for one in _all_lines(got) if one["이름"].startswith("공구손료"))
assert "잔디깎기요율.요율 %" in extra["이름글"]
assert "QC001882" not in extra["이름글"]
assert any(one["이름"] == "잔디깎기요율" for one in got["별칭"])
def test_짧은_이름은_규격_코드를_떼고_길면_줄인다() -> None:
short = mt.mc.short
assert short("바퀴숫돌 평면용 A24 QWV1호 A205×25×25 KSL 6501") == "바퀴숫돌평면용"
assert short("크롤러드릴(공기식)(17㎥/min)") == "크롤러드릴공기식"
assert short("콘크리트 피니셔(중앙분리대용) 105.9㎾") == "콘크리트피니셔"
assert short("1급 기준점 측량") == "기준점측량" # 숫자로 시작하지 않음
assert short("잔디깎기 연간 시공횟수별 시공량 할증율") == "잔디깎기할증율"
def test_이름글_별칭은_찾은_줄_값으로_갈리고_표_키_번호가_없다() -> None:
"""번호(가스압접1) · 표 키(QC000568) 대신 표 제목 + 찾은 줄 값 · 되돌리면 원래 부르기."""
files = store.cm.load(folder=REAL)
master = store.cm.master(REAL)
want = {
"GC000337": "낙석방지망설치재료_철망.수량",
"GC000360": "가스압접_용접공.수량",
"GC000350": "터널바닥암반청소_굴착기_02.",
"GF000185": "구체콘크리트펌프카타설_레미콘.",
}
for key, part in want.items():
got = mt.lines(files, key, dict(store.cm.시험입력(master.logic(key))))
names = [one["이름글"] for one in _all_lines(got)]
assert any(part in one for one in names), (key, names)
assert not any(re.search(r"\b[A-Z]{2}\d{6}", one) for one in names), (key, names)
raw_of = {m["이름"]: m["원문"] for m in got["별칭"]}
for one in names: # 이름글 속 별칭은 모두 원문 부르기로 되돌려짐
back = mt.mc._unmask(one, raw_of)
left = [n for n in raw_of if re.search(rf"(?<![\w.]){re.escape(n)}(?!\w)", back)]
assert not left, (key, back)
assert any("찾기(" in mt.mc._unmask(one, raw_of) for one in names)
def test_긴_품명은_앞_핵심만_겹치면_꼬리_2() -> None:
files = store.cm.load(folder=REAL)
master = store.cm.master(REAL)
for key in ("GC000325", "GC000360"):
got = mt.lines(files, key, dict(store.cm.시험입력(master.logic(key))))
names = [one["이름글"] for one in _all_lines(got)]
assert not any(len(w) > 20 for one in names for w in re.findall(r"[^\W\d]\w*", one))
if key == "GC000325":
assert any(one.startswith("콘크리트피니셔노무비단가 * ") for one in names)
else:
assert "보통인부노임_2 * 0 = 보통인부비_2" in names
# ── PLAN 2-1 · 2-2 — 조각(알약) ─────────────────────────────────────────
def test_조각이_이름글_금액_까닭_곁에_칸으로_더해진다(client: TestClient) -> None:
"""지금 주던 이름글·글·금액·까닭은 그대로 두고 조각 칸만 더함(계약 확인)."""
got, calc = _both(client, STACK)
mason = _all_lines(got)[0]
assert mason["이름"] == "석공" and mason["글"].startswith("268,908 * ")
assert Decimal(str(got["계"])) == Decimal(str(calc["sums"]["계"]))
assert isinstance(mason["조각"], list) and mason["조각"]
kinds = {p["kind"] for p in mason["조각"]}
assert kinds <= {"요소", "표", "로직", "값", "기호", "글"}
표 = next(p for p in mason["조각"] if p["kind"] == "표")
assert (
표["참조"]["테이블"] == "QF"
and 표["참조"]["키"] == "QF000421"
and 표["참조"]["열"] == "석공"
)
assert any(p["kind"] == "글" and p["글"] == "%" for p in mason["조각"])
def test_조각_요소는_알약이고_참조에_테이블과_키가_있다() -> None:
files = {
"재료_test.json": {
"그룹": "재료",
"줄": [{"키": "MT000001", "이름": "테스트자재", "값": Decimal("100")}],
}
}
master = mt.mf.Master(files)
piece = mt._elem_piece(master, "MT000001")
assert piece == {
"kind": "요소",
"글": "테스트자재단가",
"참조": {"테이블": "MT", "키": "MT000001"},
}
def test_조각_자리_표시_든_요소_참조는_이름만_있고_참조는_빔() -> None:
"""PLAN 2-2 ② — 자리 표시(`{…}`) 든 요소 참조는 값(참조)을 못 구해 이름만."""
master = mt.mf.Master({})
piece = mt._elem_piece(master, "LB:{직종}")
assert piece["kind"] == "요소" and "참조" not in piece
assert piece["글"] # 이름 자리는 비지 않음(못 풀어도 원문 그대로)
def test_조각_만약은_쉬운_말로_안_걸린_갈래가_흐리다() -> None:
"""PLAN 3-3 — 「조건 이면 A · 아니면 B」 · 안 걸린 갈래 조각에 흐림."""
env = {"폼타이": "사용"}
node = mt.mf.parse("만약(폼타이 == '사용', 2.14 / 10, 0)")
pieces = mt._pieces(node, node, env, mt.mf.Master({}), {})
assert [p["글"] for p in pieces] == ["폼타이 가 사용 이면", "2.14", "÷", "10", "· 아니면", "0"]
assert [bool(p.get("흐림")) for p in pieces] == [False, False, False, False, True, True]
off = mt._pieces(node, node, {"폼타이": "아님"}, mt.mf.Master({}), {})
assert [bool(p.get("흐림")) for p in off] == [False, True, True, True, False, False]
def test_조각_만약은_조건_입력이_비면_두_갈래_다_흐림_없음() -> None:
"""조건이 안 셈해지면(모르는 이름) 두 갈래 다 · 흐림 없음 · 깊이를 적어 접을 수 있게."""
node = mt.mf.parse("만약(폼타이 == '사용', 2, 3)")
pieces = mt._pieces(node, node, {}, mt.mf.Master({}), {})
assert [p["글"] for p in pieces] == ["폼타이 가 사용 이면", "2", "· 아니면", "3"]
assert not any("흐림" in p for p in pieces)
assert [p.get("깊이") for p in pieces] == [None, 1, 1, 1]
assert mt.named(node, node, {}, mt.mf.Master({})) == "만약(폼타이 == '사용', 2, 3)"
def test_조각_로직_부르는_줄_990개_세_비목에_다_걸치고_계산_전엔_금액이_빈다(
client: TestClient,
) -> None:
"""PLAN 2-2 ③ — 계산이 막히면(재료 단가 없음 따위) 이름 식·조각은 구조로 남고 금액만 빔.
비목이 안 정해진 로직 부르는 줄은 세 비목에 다 걸쳐 보여야 하나, 이 견본(STACK)은
호표 둘 다 비목이 「노무비」로 정해진 인력 줄이라 한 비목에만 걸림 — 그 좁은 경우 확인."""
got = client.get("/api/m01/logic", params={"key": STACK}).json()
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)
assert text.status_code == 200, text.text
out = text.json()
assert out["ok"] is True and out["계"] is None
rows = _all_lines(out)
assert [one["이름"] for one in rows] == ["석공", "보통인부"]
for one in rows:
assert one["금액"] is None and one["글"] == "" and "까닭" not in one
assert one["조각"] # 수량 식은 깨진 요소와 무관해 구조로 그대로 남음
assert [g["소계"] for g in out["groups"]] == [None]
def test_자리_표시_든_참조는_이름_입력값으로_읽히고_참조는_풀린_키() -> None:
"""GF000081 잡품 — 「MO:휘발유:{지역}」 날글 대신 「휘발유 · 전국평균」 · 참조 = 풀린 MO 키."""
files = store.cm.load(folder=REAL)
master = store.cm.master(REAL)
row = master.logic("GF000081")
def pills(given: dict) -> tuple[list, str]:
got = mt.lines(files, "GF000081", given)
one = next(o for o in _all_lines(got) if o["이름"] == "잡품")
return [p for p in one["조각"] if p["kind"] == "요소"], one["이름글"]
filled, name_text = pills(dict(store.cm.시험입력(row)))
assert [p["글"] for p in filled] == ["휘발유 · 전국평균"]
assert filled[0]["참조"]["키"] == "MO000001" and "MO:" not in name_text
blank, name_text = pills({})
assert [p["글"] for p in blank] == ["휘발유 · 지역"] and "참조" not in blank[0]
assert "{" not in name_text and "MO:" not in name_text
def test_자리_표시_참조가_조각_요소조각_이름식에_날글로_남지_않는다() -> None:
files = store.cm.load(folder=REAL)
master = store.cm.master(REAL)
for key in ("GC000138", "GC000211", "GC000267", "GC000559", "GF000081"):
for given in (dict(store.cm.시험입력(master.logic(key))), {}):
for one in _all_lines(mt.lines(files, key, given)):
shown = [one["이름글"], *(p["글"] for p in one["조각"] + one["요소조각"])]
assert not any(re.search(r"[A-Z]{2}:|[{}]", t) for t in shown), (key, shown)
def test_표_조각_참조_줄은_엔진이_찾은_줄의_차례다() -> None:
"""GC000010 크레인 — 줄에 없는 조건 칸은 맞음이라 흉내 내면 틀림 · GF000160 합판도."""
files = store.cm.load(folder=REAL)
master = store.cm.master(REAL)
for key in ("GC000010", "GF000160"):
got = mt.lines(files, key, dict(store.cm.시험입력(master.logic(key))))
tables = [p for one in _all_lines(got) for p in one["조각"] if p["kind"] == "표"]
assert tables and all("줄" in p["참조"] for p in tables), key
for p in tables:
rows = master.get(p["참조"]["키"])["줄"]
hit = rows[p["참조"]["줄"]]
assert hit is mt.mf.find(master.get(p["참조"]["키"]), p["참조"]["행"], p["참조"]["열"])
got = mt.lines(files, "GC000010", dict(store.cm.시험입력(master.logic("GC000010"))))
pill = next(
p
for one in _all_lines(got)
for p in one["조각"]
if p["kind"] == "표" and p["참조"]["키"] == "QC000031" and "크레인" in p["글"]
)
assert master.get("QC000031")["줄"][pill["참조"]["줄"]]["구분"] == "크레인"
def test_합판거푸집_표_조각_글은_줄마다_다르고_참조에_찾기_조건이_있다(client: TestClient) -> None:
"""PLAN 3-3 — 글 = 「찾은 줄 · 칸」 · 참조.행 = 찾기 조건 · 중간 값은 글에 이름."""
got, _ = _both(client, FORM)
tables = [p for one in _all_lines(got) for p in one["조각"] if p["kind"] == "표"]
assert len(tables) == 7 and len({p["글"] for p in tables}) == 7
plywood = next(p for p in tables if p["글"] == "합판 · 1회사용")
assert plywood["참조"]["행"] == {"구분": "합판"} and plywood["참조"]["열"] == "기준수량_1회사용"
rate = next(p for p in _all_lines(got)[0]["조각"] if p["kind"] == "값")
assert rate["글"] == "인력율" and rate["값"] == "1.31"
tie = _all_lines(got)[-1]["조각"]
assert tie[0]["글"] == "폼타이 가 사용 이면" and [bool(p.get("흐림")) for p in tie][1] is True
def test_값_없이_열어도_텍스트가_멈추지_않는다(client: TestClient) -> None:
got = client.post("/api/m01/text", json={"key": FORM, "inputs": {}}).json()
assert got["ok"] is True
tie = _all_lines(got)[-1]
assert "만약(폼타이 == '사용'" in tie["이름글"] and not any("흐림" in p for p in tie["조각"])
def test_모든_로직을_값_없이_돌려도_멈추지_않는다() -> None:
files = store.cm.load(folder=REAL)
master = store.cm.master(REAL)
stops = []
keys = [k for rows in master.index.values() for k in rows]
for key in spread([k for k in keys if mt.mf.mk.GROUP_OF.get(k[:2]) == "로직"], 400):
try:
mt.lines(files, key, {})
except mt._CALC_ERRORS as e:
stops.append((key, str(e)))
assert not stops, stops[:3]
def test_글_안의_돈은_정수_계산_값은_소수_그대로(client: TestClient) -> None:
assert mt.fmt_money(Decimal("79482.678")) == "79,483"
assert mt.fmt_money(Decimal("0.4")) == "0"
got, _ = _both(client, FORM)
first = _all_lines(got)[0]
assert first["글"] == "275,790 * 0.22 * 1.31 = 79,482.6" # 수량·비율은 소수 그대로
assert Decimal(str(first["금액"])) == Decimal(
"79482.6"
) # 줄 0.1 원 버림(751-3 · 옛 79,482.678)
def test_자동값으로_모든_로직을_돌려도_멈추지_않는다() -> None:
"""빈 줄(후보 0 · 값 빈 품목) — 그 줄만 빈 글 · 로직은 계속(PLAN 3-2)."""
files = store.cm.load(folder=REAL)
master = store.cm.master(REAL)
stops = []
keys = [k for rows in master.index.values() for k in rows]
for key in spread([k for k in keys if mt.mf.mk.GROUP_OF.get(k[:2]) == "로직"], 400):
given = {n: store._dec(v) for n, v in old_engine.auto(key)["값"].items()}
# 고르기가 빈 입력 = 내 기계 · 불러오기 전용 식(M01 정본 기계가 안 씀) — 자동값 고를 것이 없음
if any(i.get("고르기") == [] for i in master.logic(key).get("입력", [])):
continue
try:
mt.lines(files, key, given)
except mt._CALC_ERRORS as e:
stops.append((key, str(e)))
assert not stops, stops[:3]
def test_빈_줄은_빈_글이고_소계는_빈_줄_빼고_더한다(client: TestClient) -> None:
key = "GC000027"
given = {n: str(v) for n, v in old_engine.auto(key)["값"].items()}
got = client.post("/api/m01/text", json={"key": key, "inputs": given}).json()
calc = client.post("/api/m01/calc", json={"key": key, "inputs": given}).json()
assert got["ok"] is True
blank = [one for one in _all_lines(got) if one["금액"] is None]
assert blank and all(one["글"] == "" and one["까닭"] for one in blank)
assert Decimal(str(got["계"])) == Decimal(str(calc["sums"]["계"]))
def test_곱_뒤_덧셈_묶음은_괄호로_이름_식_값_식_모두() -> None:
"""GC000467 촌락지대가 — 노임 * (아홉 항 합) · 첫 항에만 곱하는 것처럼 읽히지 않게."""
files = store.cm.load(folder=REAL)
row = store.cm.master(REAL).logic("GC000467")
given = {n: store._dec(v) for n, v in old_engine.auto("GC000467")["값"].items()}
got = mt.lines(files, "GC000467", given)
one = _all_lines(got)[0]
assert one["글"].startswith("295,138 * (1 + 1 + 0.5") and " = 3,984,363" in one["글"]
left = one["이름글"].split(" = ")[0]
assert left.startswith("중급기술자건설노임 * (") and left.endswith(".수량)")
assert Decimal(str(one["금액"])) == Decimal("295138") * Decimal("13.5")
blank = mt.lines(files, "GC000467", {})
assert _all_lines(blank)[0]["이름글"].split(" = ")[0].count("(") == 1 # 값 없이도 그대로
assert row # 로직이 있음
def test_이름글_번호_별칭은_별칭표로_되돌려진다() -> None:
"""이름글 속 별칭(가1~가9)은 별칭표 이름 그대로여야 식으로 되돌려짐(찾은 줄 이름 X)."""
files = store.cm.load(folder=REAL)
given = {n: store._dec(v) for n, v in old_engine.auto("GC000467")["값"].items()}
got = mt.lines(files, "GC000467", given)
left = _all_lines(got)[0]["이름글"].split(" = ")[0].split(" * ", 1)[1].strip("()")
raw_of = {m["이름"]: m["원문"] for m in got["별칭"]}
back = mt.mc._unmask(left, raw_of)
assert back.count("찾기(") == 9 and "촌락지대가" not in back
def test_요소조각_로직_부르기는_이름과_인자_글_날식_없음() -> None:
"""GC001093 트럭 줄 — 로직 조각(키 GC000268) + 인자 글(기계 이름 · 지역 지금 값)."""
files = store.cm.load(folder=REAL)
row = store.cm.master(REAL).logic("GC001093")
given = dict(store.cm.시험입력(row))
for got in (mt.lines(files, "GC001093", given), mt.lines(files, "GC001093", {})):
lines = _all_lines(got)
assert all("요소조각" in one for one in lines)
truck = [one for one in lines if one["이름"].startswith("트럭")]
assert truck
for one in truck:
head, args = one["요소조각"]
assert head["kind"] == "로직" and head["참조"]["키"] == "GC000268"
assert args["kind"] == "글" and "덤프트럭" in args["글"]
assert "GC000268" not in args["글"] and "(" not in args["글"].split("덤프트럭")[0]
labor = lines[0]["요소조각"]
assert labor[0]["kind"] == "요소" and labor[0]["글"] == "배관공(수도)"
def test_값_식_작은_수는_유효숫자로_보인_수끼리_곱해도_금액과_맞음() -> None:
"""GC001064 수량 0.001667 — 넷째 자리로 잘라 456 이 465 로 읽히던 것."""
files = store.cm.load(folder=REAL)
row = store.cm.master(REAL).logic("GC001064")
got = mt.lines(files, "GC001064", dict(store.cm.시험입력(row)))
first = _all_lines(got)[0]["글"]
assert first == "273,308 * 0.001667 = 455.5" # 줄 0.1 원 버림(751-3)
assert mt.fmt(Decimal("0.00166667")) == "0.001667" and mt.fmt(Decimal("12.34567")) == "12.3457"
assert (
mt.fmt_price(Decimal("3.5")) == "3.5" and mt.fmt_price(Decimal("3500.4")) == "3,500.4"
) # 751-2 단가 그대로
def _text_of(key: str, **given) -> list[dict]:
auto = {k: v for k, v in (old_engine.auto(key).get("값") or {}).items() if v is not None}
return _all_lines(old_engine.text(key, {**auto, **given}))
def test_빈_줄을_부른_덧줄_값_조각은_None_대신_그_줄_이름() -> None:
line = next(x for x in _text_of("GF000185") if x["이름"] == "콘크리트다짐")
texts = [p["글"] for p in line["조각"]]
assert "None" not in texts and "구체콘크리트(철근) 레미콘" in texts
def test_만약이_고른_갈래가_덧셈이면_곱셈_안에서_괄호로_묶임() -> None:
line = next(x for x in _text_of("GC000376", 면="BOX 형상 내면") if x["이름"] == "도장공")
assert line["글"] == "263,017 * 0.031 * (1 + 60 %) = 13,045.6" # 줄 0.1 원(751-3)
outer = next(x for x in _text_of("GC000376", 면="외면") if x["이름"] == "도장공")
assert "(" not in outer["글"]
def test_수량_식_안_로직_조각은_그_로직_이름() -> None:
line = next(x for x in _text_of("GC000111") if x["이름"] == "리퍼 기계경비")
pill = next(p for p in line["조각"] if p["kind"] == "로직")
assert pill["글"] == "굴착기(무한궤도) 시간당 기계경비" and pill["참조"]["키"] == "GC000267"
def test_표에_없는_입력_조합은_그_줄만_비우고_글은_그대로() -> None:
"""/calc 와 같은 빈 줄 규칙 — 풀리지 않는 중간값은 /text 도 멈추지 않음."""
got = old_engine.text("GC001000", {**old_engine.auto("GC001000")["값"], "시공구분": "기계시공"})
lines = _all_lines(got)
blank = [x for x in lines if x["금액"] is None]
assert blank and all(x["이름글"] and x["조각"] for x in blank)
assert len(blank) < len(lines) or got["계"] is not None
calc = old_engine.calc(
"GC001000", {**old_engine.auto("GC001000")["값"], "시공구분": "기계시공"}
)
assert got["계"] == calc["sums"]["계"]
def _mat_piece(lines: list[dict], name: str) -> dict:
return next(x for x in lines if x["이름"] == name)["요소조각"][0]
def test_재료_줄_요소조각은_잡힌_품목_이름과_MT_참조() -> None:
piece = _mat_piece(_text_of("GF000159"), "결속선 0.9㎜")
assert piece["글"].startswith("어닐링철선(결속선)")
assert piece["참조"] == {"테이블": "MT", "키": "MT000209"}
auto = {k: v for k, v in old_engine.auto("GF000159")["값"].items() if v is not None}
assert (
old_engine.text("GF000159", auto)["계"] == old_engine.calc("GF000159", auto)["sums"]["계"]
)
def test_고름으로_바꾼_재료_줄_요소조각은_고른_품목() -> None:
import check_master as cm
import master_pick as mp
auto = {k: v for k, v in old_engine.auto("GF000159")["값"].items() if v is not None}
items = cm.master().logic("GF000159")["호표"]
at = next(i for i, h in enumerate(items) if h.get("이름") == "결속선 0.9㎜")
with mp.choosing({at: "MT000174"}):
got = _all_lines(old_engine.text("GF000159", auto))
assert _mat_piece(got, "결속선 0.9㎜")["참조"]["키"] == "MT000174"