Files
Aislo/resources/tester/test_848_10_upper_down.py
T
eomsangdonandClaude Opus 5.5 2216951c65 fix(848-10): M01 기초 고침이 M02 단가산출로 빠짐없이 — 옵션 기본 · 따로 문서 옵션 · 글 · 굳힌 사본 · 되살림 제 그룹
- 파생 문서 = 기초 문서 옵션 기본 위에 내가 고른 값만(옛 로직 줄 자동값이 기초 고침을 안 이김) · 층바탕 위 = 같은 기초 문서
- 따로 문서 · 끊음 — 기초가 옵션 기본 · 글만 바꿈 = 다시 복사 없음 · 안 고른 옵션 · 안 고친 줄 글 따라옴 · 고른 옵션 = 내 값 지킴 + 알림([확인] 까지)
- 손고침 기초 · 굳히기 = `수식.바탕문서` 사본 → 굳힌 사본이 굳힐 때 단가산출 금액 · 프로젝트 층 = 굳은 뒤 기초 고침 안 받음(옛 칸 줄 고친 SK 빼고)
- M01 옵션 가로 = 고칠 권한이면 기초 옵션 기본값(읽기 = 미리 보기 값)
- 기초가 그룹째 뺀 줄 되살림 = 제 그룹(제목) · 제 자리
- 새 시험 test_848_10_upper_down(결과 — 새 · 있던 SK · 지킴 알림 · 글 · 굳힘 · 손고침 빌더 · 층바탕 · 되살림)
- 옛 로직 줄 자동값 ≠ 기초 옵션 기본 200 장(금액 다름 109) = 새 SK 가 M01 기초와 같은 금액 · 저장된 SK 해당 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 00:47:46 +09:00

245 lines
10 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 를 다른 시험에서 받아 씀
"""848-10 M01 기초 고침이 M02 단가산출로 내려감(요구 887 · 889 · 요구서_889 1 · 3 절).
㉡ 새 단가산출 = 고친 기초 그 상태(옵션 기본 · 입력 기본 · 줄 수량 · 줄 뺌 · 기계 고침 · 작업량 방식) —
문서 = 기초 문서 · 위덮음 = 기초 기계덮음 · 금액 = 기초 금액.
㉢ 있던 단가산출 — 안 고친 것 = 따라옴 · 다른 옵션을 고른 것 = 내 값 지킴 + 나머지 따라옴 ·
같은 옵션을 고른 것 = 내 값 지킴 + 알림 → [확인] 뒤 알림 없음 · 줄을 고친 것 + 옵션 기본 바뀜 = 줄 고침 지킴
(다시 복사 아님) · 기초 줄 이름만 바뀜 = 안 고친 줄 이름 따라옴.
㉣ 프로젝트 사본 — 고치기 전 굳힌 것 = 그대로 · 고친 뒤 굳힌 것 = 그때 단가산출 금액(손고침 기초 사본).
㉤ 손고침 기초 = 빌더가 안 덮음(그 로직 파일 글 = 저장본) · SK 층바탕 = {위: 기초, 빌더} → 기초에서 바꾼 옵션 = 위(주황).
㉥ 기초가 그룹째 뺀 줄 되살림 = 제 그룹(제목)으로 · 처음 문서 차례.
정본 파일 안 고침 — 수식 문서 폴더 = 임시 사본 · 층 = 임시 storage.
"""
from __future__ import annotations
import copy as cp
import importlib
import json
import shutil
import pytest
from M01_MasterData import M01_MasterData_Doc as m01doc
from M01_MasterData import M01_MasterData_Store as m01
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_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
from resources.tester.test_848_1_cover_layers import docs_tmp # noqa: F401
from resources.tester.test_848_8_diff import _node
from resources.tester.test_m02_labor_ref import world # noqa: F401
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")
CON = "GC000198" # 레디믹스트콘크리트 타설 — 선택 · 입력 옵션 · 인력 둘 · 굴착기 · 공구손료
CUT = "GC000088" # 터파기(기계) — 옵션 Type 이 굴착기를 고름
NO, SYM = "0201-0100", "P_굴착기무한궤"
def _j(v):
return json.loads(json.dumps(ml._norm(v), ensure_ascii=False, default=str))
def _at(folder, fn, *a):
with store.at(folder):
return fn(*a)
def _sk(me, base: str) -> str:
body = {"이름": "sub2임시 848-10", "단위": "㎥", "더한줄": [], "바탕": {"로직": base}}
return _at(me, lambda: refs.create("sangeun", body)["이름"])
def _read(folder, key):
return _at(folder, path.read, key)
def _edit_sk(me, key, fn) -> None:
got = _read(me, key)
doc = cp.deepcopy(got["문서"])
fn(doc)
_at(me, path.save, key, {"문서": doc, "판": got["판"]})
def _m01(key, fn) -> dict:
doc = _j(m01doc.read(key)["문서"])
fn(doc)
return m01doc.save(doc)
def _opt(key, val):
def fn(d):
next(v for v in d["변수"] if v.get("열쇠") == key)["연결"]["값"] = val
return fn
def _val(doc, key):
return renew._opts(doc).get(key)
def _bare(doc) -> str:
drop = ("키", "이름", mcv.COVER, mcv.HAND, "쌓기", "판", "꼴")
return dc.fp(_j({k: v for k, v in (doc or {}).items() if k not in drop}))
def _is_base(got, key) -> bool:
"""단가산출 = 그 기초 그대로(문서 · 위덮음 · 금액)."""
live = dc.folder()[key]
return (
_bare(got["문서"]) == _bare(live)
and _j(got.get("위덮음") or {}) == _j(mcv.cover_of(live))
and got["셈"]["계"] == m01doc.read(key)["셈"]["계"]
)
def _drop_line(d):
del d["금액"][1]
def _cover(entry):
return lambda d: d.update({mcv.COVER: entry})
EDITS = {
"옵션 선택": (CON, _opt("구조물", "철근구조물")),
"옵션 입력": (CON, _opt("소량감률", "20")),
"옵션 기계": (CUT, _opt("Type", "TypeⅢ")),
"줄 수량": (CON, lambda d: d["금액"][0].update(수량="Q_콘크리트공 × 1.1")),
"줄 뺌": (CON, _drop_line),
"기계 값": (CUT, _cover({NO: {"값": {"가격": 200000}}})),
"작업량 방식": (CUT, _cover({SYM: {"작업량": {"방식": "시간당", "식": "GC001147"}}})),
}
@pytest.mark.parametrize("name", list(EDITS))
def test_새_단가산출_있던_단가산출_따라옴(world, docs_tmp, name):
key, fn = EDITS[name]
me = world["personal"]
old = _sk(me, key)
was = m01doc.read(key)["셈"]["계"]
assert _is_base(_read(me, old), key)
_m01(key, fn)
assert m01doc.read(key)["셈"]["계"] != was # ㉠ 기초 셈이 바뀜
assert _is_base(_read(me, _sk(me, key)), key) # ㉡ 새 단가산출
assert _is_base(_read(me, old), key) # ㉢ 안 고친 단가산출
def test_옵션_고름_지킴_알림_확인(world, docs_tmp):
me = world["personal"]
other, same, line = _sk(me, CON), _sk(me, CON), _sk(me, CON)
_edit_sk(me, other, _opt("타설방법", "장비사용타설"))
_edit_sk(me, same, _opt("지역", "서울"))
_edit_sk(me, line, lambda d: d["금액"][0].update(수량="(Q_콘크리트공) × 2"))
_m01(CON, _opt("지역", "경기"))
got = _read(me, other) # 다른 옵션을 고름 = 내 값 지킴 · 기초 옵션 따라옴 · 알림 없음
assert (_val(got["문서"], "타설방법"), _val(got["문서"], "지역")) == ("장비사용타설", "경기")
assert got["사본"]["따로"] and got["사본"]["갱신"] == []
got = _read(me, same) # 같은 옵션을 고름 = 내 값 지킴 + 알림
assert _val(got["문서"], "지역") == "서울"
[note] = got["사본"]["갱신"]
assert (note["갈래"], note["처리"]) == ("문서", "지킴")
assert note["M01"] == ["지역 전국평균 → 경기"] and note["내고침"] == ["지역 서울"]
_at(me, path.save, same, {"할일": renew.CONFIRM, "판": got["판"]})
after = _read(me, same)
assert after["사본"]["갱신"] == [] and _val(after["문서"], "지역") == "서울"
assert after["셈"]["계"] == got["셈"]["계"]
got = _read(me, line) # 줄 고침 + 옵션 기본 바뀜 = 줄 고침 지킴(다시 복사 아님) · 옵션 따라옴
assert got["문서"]["금액"][0]["수량"] == "(Q_콘크리트공) × 2"
assert _val(got["문서"], "지역") == "경기" and got["사본"]["갱신"] == []
def test_기초_줄_이름_따라옴(world, docs_tmp):
me = world["personal"]
key = _sk(me, CON)
_edit_sk(me, key, lambda d: d["금액"][1].update(수량="(Q_보통인부) × 2"))
_m01(CON, lambda d: [d["금액"][i].update(이름=f"848-10 이름 {i}") for i in (0, 1)])
lines = _read(me, key)["문서"]["금액"]
assert lines[0]["이름"] == "848-10 이름 0" # 안 고친 줄 = 따라옴
assert (
lines[1]["이름"] == "보통인부" and lines[1]["수량"] == "(Q_보통인부) × 2"
) # 고친 줄 = 내 것
def _freeze(me, key):
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)
return lambda: float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"])
def test_프로젝트_사본(world, docs_tmp):
me = world["personal"]
key = _sk(me, CON)
before = _freeze(me, key)
was = before()
proj = me.parent / "p84810" / "templates"
(proj / "sangeun").mkdir(parents=True)
shutil.copy(me / "sangeun" / f"{key}.json", proj / "sangeun" / f"{key}.json")
in_proj = _read(proj, key)
_m01(CON, lambda d: d["금액"][0].update(수량="Q_콘크리트공 × 1.1"))
now = float(_read(me, key)["셈"]["계"])
assert now != was
assert before() == was # 고치기 전 굳힌 것 = 그대로
p = _read(proj, key) # 프로젝트 층 = 그대로
assert p["셈"]["계"] == in_proj["셈"]["계"] and _bare(p["문서"]) == _bare(in_proj["문서"])
assert _freeze(me, key)() == now # 고친 뒤 굳힘 = 그때 단가산출 금액
def test_손고침_빌더_층바탕(world, docs_tmp):
_m01(CUT, _opt("Type", "TypeⅢ"))
saved = ml.load_all()[CUT]
assert saved.get(mcv.HAND)
files, whole = m01.loaded()
name = next(
n
for n, d in files.items()
if d.get("그룹") == "로직" and any(str(r.get("키")) == CUT 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(),
}
file = ml.FOLDER / ml.file_of(name)
assert build.files_of(result)[ml.file_of(name)] == file.read_text(encoding="utf-8")
assert CUT in build.hand_kept(result)
me = world["personal"]
got = _read(me, _sk(me, CUT))
assert _val(got["문서"], "Type") == "TypeⅢ" and set(got["층바탕"]) == {"위", "빌더"}
shown = _node(
{"문서": got["문서"], "위": got["층바탕"]["위"], "빌더": got["층바탕"]["빌더"], "고침": []}
)[0]
[(where, (kind, was, back))] = shown["표시"].items() # 기초에서 바꾼 옵션 = 위(주황)
assert (where, kind, was["연결"]["값"], back) == ("v:Type", "upper", "TypeⅠ", False)
assert shown["빠짐"] == {} and shown["줄틀"] == {}
def test_그룹째_뺀_줄_되살림_제_그룹():
top = _j(ml.load_all()["GC000994"]) # 인력 · 크롤러드릴 · 공기압축기 · 크레인 그룹
up = cp.deepcopy(top)
del up["금액"][4] # 공기압축기 그룹째
got = _node({"문서": up, "위": up, "빌더": top, "고침": [{"꼴": "되살림", "항목": 2}]})
doc = got[0]["문서"]
assert [x["이름"] for x in doc["금액"]] == [x["이름"] for x in top["금액"]]
heads = [(x.get("제목"), [y.get("이름") for y in x["줄"] if "금액" in y]) for x in doc["쌓기"]]
assert heads[2] == ("공기압축기 21㎥/min", ["공기압축기 21㎥/min"]) # 제 그룹 · 제 자리
titles = ["인력", "크롤러드릴(공기식) 17㎥/min", "공기압축기 21㎥/min", "크레인"]
assert [h[0] for h in heads] == titles
assert got[0]["빠짐"] == {}