- 읽기 답 `층바탕` = {위: 위 층 문서, 빌더?: 기초 손고침 때 빌더 문서} — M01 기초 = 빌더가 지을 문서 · M02 SK = 그 기초 지금 문서(옵션 값 = 파생과 같게 옛 로직 줄 기본) · 가져온 식 = 불러올 때 문서(`처음`) · 파일 안 씀
- 화면 = 다 그린 뒤 한 번 훑어 칸마다 부품 `setUiDiff`(나 = 파랑 · 위 = 주황) — 옵션 가로 · 공식 값 · 식 글 · 표 값 · 단위 · 금액 줄 자원 · 이름 · 단가 식 · 수량 · 단위 · 비목 · 그룹 이름 · 글 줄 · 더한 줄 · 차례 바뀐 줄 = 줄 틀 · 빠진 줄 = 그룹 머리 [되살림 n]
- 칸 [↶] · 줄 [↶] · 되살림 = 캐시 → [저장] · 읽기 계정 = 테두리만
- 저장 — 따로 사본을 다 되돌려 위 층과 같으면 파생으로(고침 흔적 0 · 끊음 · 기계 고침 있으면 그대로 · 옛 끊음 안 실음)
- 덮인 기계 칸 「원래 값 —」(836-1 부터) = 연결 기록에 작업량만 얹은 셈을 한 번 더 — 덮음 없는 정본 값이 실림(M01 · M02)
- 시험 test_848_8_diff — 수식 문서 1,520 장 고침 없이 표시 0 · 칸 · 줄 · 층 · 서버 바탕 · 파생 복귀 · 덮음 기록
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
140 lines
6.7 KiB
Python
140 lines
6.7 KiB
Python
"""848-8 바뀐 자리 표시 2 단계(요구 889 · 요구서_889 5 장) — 칸 단위 바탕 지도 · 칸 · 줄 되돌림 · 파생 복귀.
|
||
|
||
짝 = `common_util/common_util_line_stack_diff.ts`(화면 테두리 · [↶] · [되살림]) · 서버 읽기 답 `층바탕`
|
||
(`M02_Doc_Sk_Path.layers` · `M01_MasterData_Doc.read`) · 저장 `plain`(위 층과 같아지면 파생 · 흔적 0).
|
||
① 전수 — 수식 문서 1,520 장을 줄 쌓기로 차려 되굳혀도 위 층(제 문서)과 표시 0.
|
||
② 칸 — 옵션 · 수량 고침 = 나 · [↶] 되돌림 = 표시 0 · 줄 뺌 = 그룹 [되살림] · 되살림 = 처음 문서와 같음 · 차례 = 줄 틀.
|
||
③ 층 — 기초에서 바꾼 칸(빌더 대 기초) = 위(주황 · 되돌림 없음) · 내가 또 고치면 나 · 기초가 뺀 줄 되살림 = 빠짐 없음.
|
||
④ 서버 — SK 읽기 `층바탕.위` = 그 기초 문서(옵션 = 파생과 같음 → 고침 없는 SK 표시 0) · 고침 저장 = 따로 ·
|
||
다 되돌려 저장 = 파생(따로 없음) · 덮인 기계 칸이 있어도 기록에 덮음 없는 셈의 연결이 다 실림(「원래 값」).
|
||
"""
|
||
|
||
import copy as cp
|
||
import importlib
|
||
import json
|
||
import os
|
||
import subprocess
|
||
|
||
from M01_MasterData import M01_MasterData_Store as m01 # noqa: F401 — scripts 길을 둠
|
||
|
||
ml = importlib.import_module("master_doc_link")
|
||
mcv = importlib.import_module("master_doc_cover")
|
||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||
NO = "0201-0070" # 굴착기(무한궤도) 0.7㎥ — GF000099 기계
|
||
|
||
|
||
def _node(ask):
|
||
proc = subprocess.run(
|
||
["node", os.path.join(HERE, "helper_848_8_diff.cjs")],
|
||
input=json.dumps(ask, ensure_ascii=False),
|
||
capture_output=True,
|
||
text=True,
|
||
encoding="utf-8",
|
||
)
|
||
assert proc.returncode == 0, proc.stderr[-2000:]
|
||
return json.loads(proc.stdout)
|
||
|
||
|
||
def _js(d):
|
||
return json.loads(json.dumps(ml._norm(d), ensure_ascii=False, default=str))
|
||
|
||
|
||
def _sample():
|
||
return _js(ml.load_all()["GC000994"]) # 인력 셋 · 기계 셋 · 옵션 · 표 값
|
||
|
||
|
||
def test_전수_고침_없으면_표시_0():
|
||
cases = [{"키": k, "문서": _js(d)} for k, d in ml.load_all().items()]
|
||
assert len(cases) >= 1500
|
||
assert _node({"전수": cases}) == []
|
||
|
||
|
||
def test_칸_줄_되돌림():
|
||
d = _sample()
|
||
opt = d["변수"][0]
|
||
oid = "S_지반구분"
|
||
other = next(x for x in opt["연결"]["목록"] if x != opt["연결"]["값"])
|
||
want = {"변수": True, "연결": {**opt["연결"], "값": other}, "이름": opt["이름"]}
|
||
steps = [
|
||
{"꼴": "칸", "경로": f"v:{oid}", "값": want},
|
||
{"꼴": "칸", "경로": "m:1:수량", "값": "9"},
|
||
{"꼴": "줄뺌", "줄": 2},
|
||
{"꼴": "되돌림", "경로": f"v:{oid}"},
|
||
{"꼴": "되돌림", "경로": "m:1:수량"},
|
||
{"꼴": "되살림", "항목": 0},
|
||
{"꼴": "옮김", "항목": 0, "줄": 1, "곳": 4},
|
||
]
|
||
got = _node({"문서": d, "위": d, "고침": steps})
|
||
assert got[0]["표시"][f"v:{oid}"][:3:2] == ["mine", True]
|
||
assert got[1]["표시"]["m:1:수량"] == ["mine", d["금액"][1]["수량"], True]
|
||
assert got[2]["빠짐"] == {"0": ["mine", [2]]}
|
||
assert f"v:{oid}" not in got[3]["표시"]
|
||
assert got[4]["표시"] == {} and got[4]["빠짐"] == {"0": ["mine", [2]]}
|
||
assert got[5] == {**got[5], "표시": {}, "줄틀": {}, "빠짐": {}} # 되살림 = 처음과 같음
|
||
assert sorted(x["이름"] for x in got[5]["문서"]["금액"]) == sorted(x["이름"] for x in d["금액"])
|
||
assert list(got[6]["줄틀"].values()) == ["mine"] # 차례 바뀐 줄 하나
|
||
|
||
|
||
def test_층_위에서_바꾼_칸():
|
||
top = _sample()
|
||
top["금액"][1]["수량"] = "Q_특별인부"
|
||
up = cp.deepcopy(top)
|
||
up["금액"][1]["수량"] = "Q_특별인부 × 1.1"
|
||
del up["금액"][4] # 공기압축기 줄 — 기초에서 뺌
|
||
got = _node(
|
||
{
|
||
"문서": up,
|
||
"위": up,
|
||
"빌더": top,
|
||
"고침": [
|
||
{"꼴": "칸", "경로": "m:1:수량", "값": "Q_특별인부 × 1.1"},
|
||
{"꼴": "칸", "경로": "m:1:수량", "값": "5"},
|
||
{"꼴": "되돌림", "경로": "m:1:수량"},
|
||
{"꼴": "되살림", "항목": 2},
|
||
],
|
||
}
|
||
)
|
||
assert got[0]["표시"] == {"m:1:수량": ["upper", "Q_특별인부", False]}
|
||
assert list(got[0]["빠짐"].values()) == [["upper", [4]]]
|
||
assert got[1]["표시"]["m:1:수량"] == ["mine", "Q_특별인부 × 1.1", True]
|
||
assert got[2]["표시"]["m:1:수량"][0] == "upper"
|
||
assert got[3]["빠짐"] == {} and list(got[3]["줄틀"].values()) == ["mine"]
|
||
|
||
|
||
def test_서버_바탕_지도_파생_복귀_덮음_기록(tmp_path, monkeypatch):
|
||
from M02_MasterTemplete import M02_Doc_Screen as screen
|
||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||
from resources.tester.test_m02_labor_ref import world as make
|
||
|
||
me = make.__wrapped__(tmp_path, monkeypatch)["personal"]
|
||
with store.at(me):
|
||
body = {"이름": "sub3임시 바탕", "단위": "㎥", "바탕": {"로직": "GF000099"}, "더한줄": []}
|
||
key = refs.create("sangeun", body)["이름"]
|
||
first = path.read(key)
|
||
assert set(first["층바탕"]) == {"위"} # 기초 손고침 없음 = 빌더 없음
|
||
shown = _node({"문서": first["문서"], "위": first["층바탕"]["위"], "고침": []})[0]
|
||
assert shown == {"표시": {}, "줄틀": {}, "빠짐": {}}
|
||
|
||
doc = cp.deepcopy(first["문서"])
|
||
doc["금액"][0]["수량"] = f"({doc['금액'][0]['수량']}) × 2"
|
||
path.save(key, {"문서": doc, "판": first["판"]})
|
||
mid = path.read(key)
|
||
assert store.read("sangeun", key)["문서"]["수식"].get("따로")
|
||
assert mid["셈"]["계"] != first["셈"]["계"]
|
||
path.save(key, {"문서": first["문서"], "판": mid["판"]})
|
||
back = store.read("sangeun", key)["문서"]["수식"]
|
||
assert not back.get("따로") and "처음" not in back
|
||
assert path.read(key)["셈"]["계"] == first["셈"]["계"]
|
||
|
||
doc = cp.deepcopy(first["문서"])
|
||
doc[mcv.COVER] = {NO: {"값": {"가격": 900000}}}
|
||
now = path.read(key)
|
||
path.save(key, {"문서": doc, "판": now["판"]})
|
||
copy = path.current(store.read("sangeun", key)["문서"])
|
||
keys = lambda rec: {json.dumps(x["p"], sort_keys=True, default=str) for x in rec["요소"]} # noqa: E731
|
||
covered = keys(screen.record(copy))
|
||
bare = keys(screen.record({**copy, "문서": {k: v for k, v in copy["문서"].items() if k != mcv.COVER}})) # fmt: skip
|
||
assert bare <= covered and len(bare) > 0 # 덮인 칸의 정본 값까지 실림
|