Files
Aislo/resources/tester/test_848_1_cover_layers.py
T
eomsangdonandClaude Opus 5.5 5673998971 feat(848-2): Doc_Sk 세 줄 — 원본 판 = 계산 내용 지문 · 파생 저장에 맡긴 칸 실음 · 알림 [확인] 때 바탕 걷음
- copy_of 원본 판 = dc.doc_fp(기초 덮음 · 글만 바뀜 = 따로 문서 그대로)
- settle 파생 갈래 = renew.KEEP(기계덮음 · 맡긴값 · 덮음바탕) 이어 실음(재생성 빼고) — 다시 복사 뒤 저장해도 기계 고침 · 옵션 값 남음
- settle 의 renew.form 에 confirm = 할일 갱신확인
- 시험 test_848_2: 「붙인 뒤」 xfail 셋 걷음 · 기초 기계덮음만 바뀜 = 따로 SK 문서 고침 그대로(sub2 남긴 경우) · ① 안 고친 칸 따라옴 금액 확인 더함
- 시험 test_848_1: M01 문서 파일 전후 바이트 비교를 줄 끝 무시로 — autocrlf 워크트리(CRLF 로 풀림)에서 저장이 LF 로 써 줄 끝만 달라 실패하던 것

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 21:05:28 +09:00

365 lines
18 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""848-1 겹쳐 덮는 층(요구 889 · 요구서_889 1 절) — 층 셈 거울 · M01 기초 고침 저장 · SK 위 층 덮음 · 빌더 이어받기.
① 거울 — 합침 · 층 합침 · 정리(위 층 대조) · 위 층 값 · 출처가 파이썬 = TS(손셈 기대값 몇 개 + 전수 대조).
㉠ M01 기초 고침(가격 · 조종원 · 작업량 시간당 + 변수) = 그 기초 셈만 바뀜 · 다른 기초 · 기계 정본 그대로 ·
문서 밖 기계 고침 뺌 · ㉥ 빌더 이어받기(덮음 얹음 · 손고침 문서 그대로 + 목록 · 같게 되돌리면 표지 없음) ·
㉣ 정본 값으로 되돌림 = 고침 0 · 문서 바이트 = 고침 전.
㉡ 그 기초로 만든 SK = 위덮음 · 금액 = 기초 금액 · SK 고침 = ② 에만 · 금액 = ① + ② 셈 · 출처 ·
㉢ ② 를 위 층 값으로 = ② 0 · ㉤ 옵션으로 기계를 바꿔 저장해도 앞 기계 고침 남음 · 문서 밖 기계 고침만 빠짐 ·
㉦ 프로젝트로 굳힘 = 굳힐 때 금액(기초가 그 뒤 바뀌어도).
㉧ 기초 A 가 B 를 부를 때 A 의 고침만 A 셈에.
정본 파일 안 고침 — 수식 문서 폴더 = 임시 사본 · 층 = 임시 storage.
"""
import copy as cp
import importlib
import json
import os
import shutil
import subprocess
from decimal import Decimal as D
import pytest
from M01_MasterData import M01_MasterData_Doc as m01doc
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Item_Prices as item_prices
from M02_MasterTemplete import M02_Item_Source as source
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Labor_SkRow as skrow
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
mc = importlib.import_module("master_doc_calc")
ml = importlib.import_module("master_doc_link")
mcv = importlib.import_module("master_doc_cover")
cv = importlib.import_module("master_doc_convert")
build = importlib.import_module("build_수식문서_802_2")
HERE = os.path.dirname(os.path.abspath(__file__))
COVER = mcv.COVER
BASE = "GC000088" # 터파기(기계) 보통토사 — 굴착기 줄 하나(TypeⅠ = 1.0㎥ · TypeⅢ = 0.6㎥)
NO, NO3 = "0201-0100", "0201-0060"
SYM = "P_굴착기무한궤" # 그 줄 단가 기호 = 작업량 덮음 열쇠(847-1)
TPL = "GC001147" # 굴착기 시간당 작업량 식
# ── ① 거울 ────────────────────────────────────────────────────────────
BASE0 = {"값": {"가격": 100, "주연료": 10}, "조종원": [{"키": "LB:1", "인": 1}],
"잡품": [{"줄": "주연료", "율": 22}], "작업량": {"f": 0.7, "E": 0.5}} # fmt: skip
U1 = {"값": {"가격": 150}, "조종원": [{"키": "LB:1", "인": 2}],
"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8}}} # fmt: skip
U2 = {"작업량": {"방식": "시간당", "식": "T1", "기계": NO3, "이름": "굴착기 0.6㎥"}}
MINES = [
None,
{"값": {"가격": 150, "주연료": 20}},
{"값": {"가격": 100}},
{"조종원": [{"키": "LB:1", "인": 2}]},
{"조종원": [{"키": "LB:1", "인": 1}]},
{"잡품": []},
{"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8, "E": 0.5}}},
{"작업량": {"방식": "일당"}},
{"작업량": {"방식": "시간당", "식": "T2", "변수": {"f": 0.8}}},
{"작업량": {"변수": {"E": 0.6}}},
{"작업량": {"방식": "시간당", "식": "T1", "기계": NO3, "이름": "굴착기 0.6㎥"}},
{"작업량": {"방식": "시간당", "식": "T1", "기계": NO, "이름": "굴착기 1.0㎥"}},
]
def test_층_합침_정리_출처_손셈():
p = mcv.prune
assert p({"값": {"가격": 150, "주연료": 20}}, BASE0, U1) == {"값": {"주연료": 20}}
assert p({"값": {"가격": 100}}, BASE0, U1) == {"값": {"가격": 100}} # 정본 값 = 위 층과 다름
assert p({"값": {"가격": 100}}, BASE0) is None # 위 층 없음 = 지금과 같음
assert p({"조종원": [{"키": "LB:1", "인": 2}]}, BASE0, U1) is None
assert (
p({"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8, "E": 0.5}}}, BASE0, U1)
is None
)
assert p({"작업량": {"방식": "일당"}}, BASE0, U1) == {"작업량": {"방식": "일당"}}
assert p({"작업량": {"방식": "일당"}}, BASE0) is None
want = {"작업량": {"식": "T2", "변수": {"f": 0.8}}} # 식 바꿈 = 위 층 변수 안 물려받음
assert p({"작업량": {"방식": "시간당", "식": "T2", "변수": {"f": 0.8}}}, BASE0, U1) == want
assert p({"작업량": {"변수": {"E": 0.6}}}, BASE0, U1) == {"작업량": {"변수": {"E": 0.6}}}
assert p(U2, BASE0, U2) is None and p(U2, BASE0) == U2
assert mcv.merge(U1, {"작업량": {"식": "T2"}})["작업량"] == {"방식": "시간당", "식": "T2"}
assert mcv.merge(U1, {"작업량": {"방식": "일당"}})["작업량"]["방식"] == "일당"
assert mcv.merge(U2, {"작업량": {"기계": NO}})["작업량"] == {
"방식": "시간당",
"식": "T1",
"기계": NO,
}
got = mcv.sources(U1, {"값": {"주연료": 20}, "작업량": {"변수": {"E": 0.6}}})
assert got == {"값.가격": "위", "조종원": "위", "작업량.방식": "위", "작업량.식": "위",
"작업량.변수.f": "위", "값.주연료": "나", "작업량.변수.E": "나"} # fmt: skip
assert mcv.sources(U1, {"작업량": {"식": "T2"}})["작업량.식"] == "나"
assert "작업량.변수.f" not in mcv.sources(U1, {"작업량": {"식": "T2"}})
assert mcv.upper_of(BASE0, U1) == {"값": {"가격": 150, "주연료": 10}, "조종원": U1["조종원"],
"잡품": BASE0["잡품"], "작업량": U1["작업량"]} # fmt: skip
mine = {"개인 EQP000001": {"값": {"가격": 1}}} # 내 기계 열쇠 = 같은 꼴
assert mcv.merge_layers(None, mine) is mine and mcv.merge_layers(mine, {}) is mine
assert mcv.merge_layers({"개인 EQP000001": U1}, mine)["개인 EQP000001"]["값"] == {"가격": 1}
def _same(a, b, where=""):
if isinstance(a, dict):
assert isinstance(b, dict) and set(a) == set(b), (where, a, b)
for k in a:
_same(a[k], b[k], f"{where}.{k}")
elif isinstance(a, list):
assert isinstance(b, list) and len(a) == len(b), (where, a, b)
for i, (x, y) in enumerate(zip(a, b)):
_same(x, y, f"{where}[{i}]")
elif isinstance(a, (int, float)) and not isinstance(a, bool):
assert float(a) == pytest.approx(b), (where, a, b)
else:
assert a == b, (where, a, b)
def test_거울_파이썬_TS_같은_답():
cases = [{"위": u, "나": m, "기본": BASE0} for u in (None, U1, U2) for m in MINES]
want = [
{
"합침": mcv.merge(c["위"], c["나"]),
"층": mcv.merge_layers(
{"K": c["위"]} if c["위"] else None, {"K": c["나"]} if c["나"] else None
),
"정리": mcv.prune(c["나"], BASE0, c["위"]) if c["나"] else None,
"위값": mcv.upper_of(BASE0, c["위"]),
"출처": mcv.sources(c["위"], c["나"]),
}
for c in cases
]
proc = subprocess.run(
["node", os.path.join(HERE, "helper_848_1_cover_layers.cjs")],
input=json.dumps({"경우": cases}, ensure_ascii=False),
capture_output=True,
text=True,
encoding="utf-8",
check=True,
)
got = json.loads(proc.stdout)["답"]
assert len(got) == len(want) == 36
for i, (a, b) in enumerate(zip(want, got)):
_same(a, b, f"경우{i}")
# ── 임시 수식 문서 폴더(정본 파일 안 고침) ──────────────────────────────
@pytest.fixture
def docs_tmp(tmp_path, monkeypatch):
dst = tmp_path / "수식문서"
shutil.copytree(ml.FOLDER, dst)
load = ml.load_all
monkeypatch.setattr(ml, "FOLDER", dst)
monkeypatch.setattr(ml, "load_all", lambda folder=dst: load(folder))
m01doc._memo.clear()
dc._FOLDER["자국"] = None
yield dst
m01doc._memo.clear()
dc._FOLDER["자국"] = None
def _json(v):
"""화면 왕복(JSON 수)."""
return json.loads(json.dumps(ml._norm(v), ensure_ascii=False))
def _norm(v):
return json.loads(json.dumps(ml._norm(v), ensure_ascii=False, sort_keys=True))
def _defaults() -> dict:
"""정본 — BASE 기본 옵션 굴착기(NO)의 덮음 없는 기본값."""
links = ml.Links(m01.loaded()[1])
memo: dict = {}
doc = {k: v for k, v in links.doc(BASE).items() if k != COVER}
mc.calc(doc, links, None, (), memo)
for (key, given), ans in memo.items():
if mcv.is_machine(sub := links.doc(key)) and mcv.machine_key(dict(given)) == NO:
lists = mcv.lists_of(links, dict(given))
return mcv.defaults_of(sub, ans["값"], mcv.row_entry(sub, lists))
raise AssertionError("굴착기 부름 없음")
def _upper(d: dict, rate=D("1.5")) -> dict:
"""기초 고침 ① — 가격 · 조종원 · 작업량(시간당 + 변수 f)."""
return {NO: {"값": {"가격": float(D(str(d["값"]["가격"])) * rate)},
"조종원": [{"키": d["조종원"][0]["키"], "인": 2}]},
SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.8}}}} # fmt: skip
def _save_m01(cover: dict | None, edit=None) -> dict:
doc = _json(m01doc.read(BASE)["문서"])
doc.pop(COVER, None)
if cover:
doc[COVER] = _json(cover)
if edit:
edit(doc)
return m01doc.save(doc)
def _calls(key: str) -> bool:
return any(
(v.get("연결") or {}).get("키") == "GC000267" for v in m01doc.docs()[key].get("변수") or []
)
def _mini():
"""빌더 한 로직 파일 몫(BASE 가 든 파일) — {결과, 쓸 글, 파일}."""
files, whole = m01.loaded()
name = next(
n
for n, d in files.items()
if d.get("그룹") == "로직" and any(str(r.get("키")) == BASE for r in d.get("줄") or [])
)
rows = files[name]["줄"]
keys = [str(r["키"]) for r in rows]
result = {
"문서": {str(r["키"]): cv.convert(whole, r)[0] for r in rows},
"파일": {name: keys},
"저장": set(keys) & build.saved_keys(),
"저장본": build.carried(),
}
return result, build.files_of(result)[ml.file_of(name)], ml.FOLDER / ml.file_of(name)
def test_M01_기초_고침_빌더_이어받기_되돌림(docs_tmp):
d = _defaults()
result, text, file = _mini()
orig = file.read_bytes()
assert text == file.read_text(encoding="utf-8") # 고침 없음 = 빌더 글 = 저장본
other = next(k for k in sorted(m01doc.docs()) if k != BASE and _calls(k))
before, other_before = m01doc.read(BASE)["셈"]["계"], m01doc.read(other)["셈"]["계"]
price = m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"]
# ㉠ 고침 저장 — 문서 밖 기계(9999) = 뺌
want = _upper(d)
got = _save_m01({**want, "9999-9999": {"값": {"가격": 1}}})
saved = ml.load_all()[BASE]
assert _norm(saved[COVER]) == _norm(want) and mcv.HAND not in saved
assert got["셈"]["계"] != before and m01doc.read(BASE)["셈"]["계"] == got["셈"]["계"]
assert m01doc.read(other)["셈"]["계"] == other_before # 다른 기초 그대로
assert m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"] == price # 기계 정본 그대로
line = next(x for x in got["셈"]["줄"] if x.get("작업량"))
assert line["작업량"]["꼴"] == "시간당" and str(line["작업량"]["변수"]["f"]) == "0.8"
# ㉥ 빌더 — 덮음 얹음(글 = 저장본)
result, text, _ = _mini()
assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == []
# ㉥ 손고침 — 줄 식을 고친 문서 = 저장본 그대로 + 목록 · 같게 되돌리면 표지 없음
def qty(text_):
return lambda doc: doc["금액"][0].update({"수량": text_})
first = m01doc.read(BASE)["문서"]["금액"][0]["수량"]
_save_m01(want, qty("Q_굴착기^표 × 9 ÷ Q_시공"))
assert ml.load_all()[BASE].get(mcv.HAND) is True
result, text, _ = _mini()
assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == [BASE]
_save_m01(want, qty(first))
assert mcv.HAND not in ml.load_all()[BASE]
# ㉣ 정본 값으로 되돌림 = 고침 0 · 바이트 = 고침 전
back = {NO: {"값": {"가격": float(d["값"]["가격"])}, "조종원": d["조종원"]},
SYM: {"작업량": {"방식": "일당"}}} # fmt: skip
got = _save_m01(back)
assert COVER not in got["문서"] and file.read_bytes().replace(b"\r", b"") == orig.replace(
b"\r", b""
) # 줄 끝(autocrlf) 무시
assert got["셈"]["계"] == before
def _sk(me) -> str:
with store.at(me):
body = skrow.logic_doc({"로직": BASE, "입력값": {}}, {}, m01.loaded()[1])
return refs.create("sangeun", {**body, "이름": "sub2임시 848"})["이름"]
def _at(me, fn, *args):
with store.at(me):
return fn(*args)
def _mixed_sum(cover: dict) -> float:
"""기초 문서(덮음 뗌)에 cover 를 얹은 셈 계 — SK 금액 대조."""
links = ml.Links(m01.loaded()[1])
doc = {k: v for k, v in links.doc(BASE).items() if k != COVER}
return float(mc.calc(doc, links, None, (), None, cover)["계"])
def test_SK_위덮음_내고침_되돌림_옵션_굳힘(docs_tmp, world):
me = world["personal"]
d = _defaults()
upper = _upper(d)
_save_m01(upper)
base_sum = float(m01doc.read(BASE)["셈"]["계"])
key = _sk(me)
got = _at(me, path.read, key)
# ㉡ ① = 위덮음 · 금액 = 기초 금액 · 파일에 굳음
assert _norm(got["위덮음"]) == _norm(upper) and COVER not in got["문서"]
assert float(got["셈"]["계"]) == base_sum
with store.at(me):
file = store.read("sangeun", key)["문서"]["수식"]
assert _norm(file[mcv.UPPER]) == _norm(upper)
# SK 에서 한 칸 더 고침 → ② 에만(① 과 같은 가격 = 지움 · 작업량 = 바꾼 변수만)
doc = cp.deepcopy(got["문서"])
doc[COVER] = {NO: {"값": {"가격": upper[NO]["값"]["가격"], "주연료": 20}},
SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.9}}}} # fmt: skip
after = _at(me, path.save, key, {"문서": doc, "판": got["판"]})
mine = {NO: {"값": {"주연료": 20}}, SYM: {"작업량": {"변수": {"f": 0.9}}}}
assert _norm(after["문서"][COVER]) == _norm(mine) and _norm(after["위덮음"]) == _norm(upper)
assert float(after["셈"]["계"]) == _mixed_sum(mcv.merge_layers(upper, mine)) != base_sum
assert mcv.sources(upper[NO], mine[NO]) == {"값.가격": "위", "조종원": "위", "값.주연료": "나"}
assert mcv.sources(upper[SYM], mine[SYM]) == {
"작업량.방식": "위", "작업량.식": "위", "작업량.변수.f": "나"
} # fmt: skip
# ㉦ 프로젝트로 굳힘 = 굳힐 때 금액(기초가 그 뒤 바뀌어도)
with store.at(me):
here = refs.here()
ref = {"층": here[0], "주인": here[1], "키": key}
rows = source.labor_doc_rows(
{"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]}
)
bundle = source.price_bundle(rows, me)
frozen = rows["참조사본"][refs.ref_id(ref)]["수식"]
assert _norm(frozen[mcv.UPPER]) == _norm(upper)
was = float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"])
assert was == float(after["셈"]["계"])
_save_m01(_upper(d, D(2))) # 기초 고침이 바뀜
now = _at(me, path.read, key)
assert float(now["셈"]["계"]) != was # 프로젝트 밖 = 지금 기초 것
assert float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"]) == was # 사본 = 굳은 것
_save_m01(upper)
# ㉢ ② 를 위 층 값으로 = ② 0
now = _at(me, path.read, key)
doc = cp.deepcopy(now["문서"])
doc[COVER] = {NO: {"값": {"주연료": d["값"]["주연료"]}},
SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.8}}}} # fmt: skip
back = _at(me, path.save, key, {"문서": doc, "판": now["판"]})
assert COVER not in back["문서"] and float(back["셈"]["계"]) == base_sum
with store.at(me):
assert COVER not in store.read("sangeun", key)["문서"]["수식"]["문서"]
# ㉤ 옵션으로 기계를 바꿔 저장 = 앞 기계 고침 남음 · 문서 밖 기계 고침만 빠짐
doc = cp.deepcopy(back["문서"])
next(v for v in doc["변수"] if v["열쇠"] == "Type")["연결"]["값"] = "TypeⅢ"
doc[COVER] = {NO: {"값": {"주연료": 20}}, "9999-9999": {"값": {"가격": 1}}}
moved = _at(me, path.save, key, {"문서": doc, "판": back["판"]})
assert moved["문서"][COVER] == {NO: {"값": {"주연료": 20}}}
line = next(x for x in moved["셈"]["줄"] if x.get("작업량"))
assert line["작업량"]["기계"] == NO3 # 셈은 바꾼 기계(앞 기계 고침은 안 걸림)
def test_A_가_B_를_부를_때_A_고침만():
links = ml.Links(m01.loaded()[1])
a, b, no = "GF000177", "GF000168", "0201-0070"
price = float(m01.loaded()[1].numbers["EQ"][no]["값"]["가격"])
cover = {no: {"값": {"가격": price * 2}}}
given = {"기초잡석량": D(1)} # A(날개벽) 기초잡석 1 ㎥ = B(기초잡석) 부름
plain_a = mc.calc(links.doc(a), links, given)["계"]
plain_b = mc.calc(links.doc(b), links)["계"]
assert plain_a > 0
with_b = ml.Links(m01.loaded()[1], {**links.docs, b: {**links.doc(b), COVER: cover}})
assert mc.calc(with_b.doc(a), with_b, given)["계"] == plain_a # B 의 고침 = A 셈에 안 걸림
assert mc.calc(with_b.doc(b), with_b)["계"] != plain_b # B 를 맨 위로 열면 걸림
mine = mc.calc({**links.doc(a), COVER: cover}, links, given)["계"]
assert mine > plain_a # A 고침 = B 안 기계 줄까지