- 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>
365 lines
18 KiB
Python
365 lines
18 KiB
Python
# 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 안 기계 줄까지
|