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:
@@ -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 ""
|
||||
@@ -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, {"전력 계약종별": "주택용 저압"})
|
||||
|
||||
@@ -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 원 버림
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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"]
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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"
|
||||
Reference in New Issue
Block a user