Files
Aislo/resources/tester/test_802_4a_m02_doc.py
T
eomsangdonandClaude Opus 5.5 35d3242711 refactor(855-E 2-E4): M02 로직 줄 옛 엔진 셈 걷음 — Labor_Doc.run_line · pct_extras · logic_mats · layered · drop_apart
- M02_Labor_Copy.line: 프로젝트 층 · `dsk.OLD` 옛 엔진 갈래 걷음(층 셈과 같은 문서 셈) · 재료 줄 `걸림`(재료 조건 ·
  요소 키 틀 구멍의 입력 이름 = 문서 몫 · 화면 `releaseTied` 가 읽음 — 옛 logic_mats 와 같은 뜻)
- M02_Labor_Doc: `run_line` · `pct_extras` · `_pct_base` · `logic_mats` · `layered` · `drop_apart` · `_specs`(mf.inputs_of) 지움
  (제품 부르는 곳 0) · 담기 검사 = 새 `_head`(문서 입력 이름 · 재료 금액 줄 차례 — M01 로직 줄 안 읽음)
- M02_Doc_Sk: 아무도 안 켜는 `OLD` ContextVar 지움
- 시험: 옛 날 답 자리 = 새 `helper_855_line.run_line`(층 문서 셈 · 재료 직접계산) — 175 · 222_1 · 715_3 ·
  715_sangeun_store · 727 · 742_1 · 747_1 · 795_1 · 795_2 · m02_labor_layer · m02_labor_logic_mats · m02_labor_ref ·
  옛 엔진만 붙든 것 걷음: test_149_4 통째(옛 % 덧줄 표기) · 751_3 다섯(run_line 끝수) · 792_3 다시 버림 ·
  802_4a 옛 길 대조(OLD · run_line) · 855_sk_layers 옛 엔진 안 돎 = master_formula.run 부름 0 으로 ·
  helper_855_old_engine_routes 의 % 덧줄 표기 = 그 도우미 안으로(옛 길 도우미 · 엔진 몸과 같이 지움)
- 222_1 시멘트 단위 글 kg → ㎏(문서 단위)
- 검증: 관련 82 파일 + 지킴 + 관문 776 통과 · 빌더 --check 같음 · typecheck 0

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

241 lines
12 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 에서 받아 씀
"""802-4a M02 단가산출 · 일위대가 · B09 사본 = 수식 문서 — 임시 storage · M01 은 메모리 덮개.
① 찍기 = M01 문서 사본(금액 = M01 문서 셈) ② 고침 = 사본 문서(M01 안 바뀜 · 옛 칸 고침 409)
③ [단가 갱신] = 자원 단가만(문서 그대로) ④ [재생성] = 지금 M01 문서 · 고친 것 버림
⑤ 단가산출 연결 = [재생성] 때 따라감 · 끊기 = 사본 안에 굳힘 ⑥ SC · 일위대가 = 문서 셈(옛 금액 같음 ·
줄 규칙 켜쌓기율 · 고른 자재 · 별도계상) ⑦ B09 사본 `수식.json` ⑧ 권한 ⑨ 지움 견딤 · 빈 SK 「—」.
"""
from __future__ import annotations
import copy
import pytest
from fastapi import HTTPException
from M02_MasterTemplete import M02_Doc_B09 as doc_b09
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Doc_Router as router
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Item_Snapshot as snap
from M02_MasterTemplete import M02_Item_Source as source
from M02_MasterTemplete import M02_Labor_Copy as lc
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from resources.tester.test_795_1_sk_copy import _calc, _changed, _doc, _fake, _live, _save, _sk
from resources.tester.test_795_2_sc_copy import LB, PCT, _double, _labor, _sc
from resources.tester.test_795_2_sc_copy import _calc as _sc_calc
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
@pytest.fixture(autouse=True)
def _manual(monkeypatch):
"""836-2 — 이 시험 = 손 갱신 길(프로젝트 층 꼴 · 자동 따라옴 끔) · 자동 = test_836_2."""
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
monkeypatch.setattr(renew, "on", lambda: False)
FORM = "GC000211" # 합판거푸집(옵션 많음)
def _sum(folder, key):
return _calc(folder, _doc(folder, key))["기준"]["계"]
def _at(folder, fn, *args):
with store.at(folder):
return fn(*args)
def _twice(doc, at=0):
"""금액 줄 하나 수량 × 2 — 사용자 고침 흉내."""
doc = copy.deepcopy(doc)
line = doc["금액"][at]
line["수량"] = f"({line.get('수량') or 1}) × 2"
return doc
def test_stamp_is_m01_doc_copy(world):
"""① 만들 때 M01 문서를 찍음 — 키 = SK · 옵션 값 · 금액 = M01 문서 셈 = 옛 금액."""
me = world["personal"]
key = _sk(me, 바탕={"로직": FORM}, 입력값={"유형": "복잡", "사용횟수": "3회"})
got = _doc(me, key)[dc.KEY]
root, m01 = got["문서"], dc.folder()[FORM]
assert root["키"] == key and [v["기호"] for v in root["변수"]] == [
v["기호"] for v in m01["변수"]
]
assert next(v for v in root["변수"] if v["열쇠"] == "유형")["연결"]["값"] == "복잡"
assert not got.get("따로") and got["로직"] and got["단가"]
m01_calc = dc.mc.calc(root, dc.ml.Links(_live(), dc.folder()))
assert _sum(me, key) == m01_calc["계"]
read = _at(me, path.read, key)
assert read["셈"]["계"] == m01_calc["계"] and read["사본"]["따로"] is False
def test_edit_goes_to_copy_doc(world):
"""② 고침 = 그 사본 문서(따로) · M01 문서 그대로 · 옛 칸 고침 저장 409 · 다시 열어 같음."""
me = world["personal"]
key = _sk(me, 바탕={"로직": PCT})
was, m01_before = _sum(me, key), dc.fp(dc.folder()[PCT])
read = _at(me, path.read, key)
pre = _at(me, path.preview, key, {"문서": _twice(read["문서"])})
assert pre["전"]["계"] == was and pre["후"]["계"] > was
saved = _at(me, path.save, key, {"문서": _twice(read["문서"]), "판": read["판"]})
assert saved["사본"]["따로"] is True and saved["셈"]["계"] == pre["후"]["계"]
assert _sum(me, key) == pre["후"]["계"] # SK 금액(일위대가가 쓰는 값) = 고친 문서
assert dc.fp(dc.folder()[PCT]) == m01_before
assert _at(me, path.read, key)["문서"] == saved["문서"]
doc = _doc(me, key)
with pytest.raises(store.StoreError) as e:
_save(me, key, {**doc, "입력값": {"x": 1}, "덮개": {"labor:LB000036#0": {"qty": 3}}})
assert e.value.status == 409
_save(me, key, {**doc, "이름": "sub2임시 이름만"}) # 머리 칸 = 그대로 받음
assert _sum(me, key) == pre["후"]["계"]
with pytest.raises(store.StoreError) as e: # 판 다름
_at(me, path.save, key, {"문서": read["문서"], "판": read["판"]})
assert e.value.status == 409
def test_price_refresh_values_only(world, monkeypatch):
"""③ [단가 갱신] = 자원 단가만 — M01 문서 바뀜은 안 따라감 · 바뀐자원 · 누르기 전 그대로."""
me = world["personal"]
key = _sk(me, 바탕={"로직": PCT})
was = _sum(me, key)
root = _at(me, path.read, key)["문서"]
_fake(monkeypatch, [_changed(_live().logic(PCT)), _double(LB)])
assert _sum(me, key) == was
pre = _at(me, path.preview, key, {"할일": "단가갱신"})
assert [x["키"] for x in pre["바뀐자원"]] == [LB] and pre["문서"] == root
fresh = _sum(me, _sk(me, 바탕={"로직": PCT})) # 새 문서 + 새 단가
assert pre["후"]["계"] != was and pre["후"]["계"] != fresh
read = _at(me, path.read, key)
got = _at(me, path.save, key, {"할일": "단가갱신", "판": read["판"]})
assert got["셈"]["계"] == pre["후"]["계"] == _sum(me, key) and got["문서"] == root
assert got["사본"]["단가새값"] is False and PCT in got["사본"]["문서새판"]
def test_regen_takes_m01_doc_drops_edits(world, monkeypatch):
"""④ [재생성] = 지금 M01 문서로 · 고친 문서 버림(알림) · 파생으로 돌아감."""
me = world["personal"]
key = _sk(me, 바탕={"로직": PCT})
read = _at(me, path.read, key)
_at(me, path.save, key, {"문서": _twice(read["문서"], 1), "판": read["판"]})
_fake(monkeypatch, [_changed(_live().logic(PCT))])
fresh = _sum(me, _sk(me, 바탕={"로직": PCT}))
pre = _at(me, path.preview, key, {"할일": "재생성", "문서": {"아무": "버려짐"}})
assert pre["버림"]["문서고침"] is True and pre["후"]["계"] == fresh
read = _at(me, path.read, key)
got = _at(me, path.save, key, {"할일": "재생성", "판": read["판"]})
assert got["사본"]["따로"] is False and got["셈"]["계"] == fresh == _sum(me, key)
assert got["사본"]["M01새판"] is False and got["사본"]["문서새판"] == []
CALLER, CALLED = "GC000006", "GC000267" # 가설울타리 강관 지주 → 굴착기(무한궤도) 시간당
def test_link_follows_on_regen_unlink_freezes(world, monkeypatch):
"""⑤ 단가산출 연결 = 부름 사본(M01 바뀌어도 그대로 · [재생성] 때 따라감) · 끊기 = 사본 안 고침."""
me = world["personal"]
key = _sk(
me, 바탕={"로직": CALLER}, 단위="m"
) # 기초 문서가 부르는 단가산출(855 2-C1 — 옛 더한줄 대신)
was = _sum(me, key)
read = _at(me, path.read, key)
assert CALLED in read["부름"]
cut = {CALLED: _twice(read["부름"][CALLED])}
pre = _at(me, path.preview, key, {"끊음": cut})
assert pre["후"]["계"] > was
saved = _at(me, path.save, key, {"끊음": cut, "판": read["판"]})
assert (
saved["끊음"][CALLED] == {**cut[CALLED], "키": CALLED} and _sum(me, key) == pre["후"]["계"]
)
_fake(monkeypatch, [_changed(_live().logic(CALLED))]) # 원본 바뀜
assert _sum(me, key) == pre["후"]["계"] # 끊은 것 · 연결 모두 그대로(누르기 전)
with pytest.raises(store.StoreError) as e: # 부르지 않는 키 끊기
_at(me, path.preview, key, {"끊음": {"GC999999": read["부름"][CALLED]}})
assert e.value.status == 400
read = _at(me, path.read, key)
pre = _at(me, path.preview, key, {"할일": "재생성"})
assert pre["버림"]["끊음"] == [CALLED]
got = _at(me, path.save, key, {"할일": "재생성", "판": read["판"]})
assert got["끊음"] == {} and got["셈"]["계"] > was # 연결 = 새 원본 따라감
def test_sc_and_labor_use_doc(world, monkeypatch):
"""⑥ SC · 일위대가 로직 줄 = 문서 셈(부름 사본) · 옛 엔진 금액과 같음 · M01 바뀌어도 그대로."""
me = world["personal"]
sc = _sc(me, [{"로직": PCT, "수량": {"손": 1}}])
_labor(me, [{"로직": FORM, "수량": {"손": 2}, "입력값": {"유형": "보통"}}])
stored = _at(me, store.read, "precombo", sc)["문서"]
assert dc.has(stored) and PCT in stored[dc.KEY]["부름"]
runs = []
real = lc._traced # 로직 줄 문서 셈(855 2-C5 — 셈 기록 같이)
monkeypatch.setattr(lc, "_traced", lambda *a, **k: runs.append(1) or real(*a, **k))
new = (_sc_calc(me, sc)["기준합"], _sc_calc(me, "sub2임시")["반영합"])
assert runs
_fake(monkeypatch, [_changed(_live().logic(PCT))])
assert _sc_calc(me, sc)["기준합"] == new[0]
def test_b09_copy_has_doc_file(world, monkeypatch):
"""⑦ B09 사본 = 단가 묶음 옆 `수식.json`(만든 때 부름) · 원본판에 듦(로직 몫 · 855-F B9-6) ·
M01 바뀌어도 그대로."""
me = world["personal"]
doc = _labor(me, [{"로직": PCT, "수량": {"손": 2}}])
rows = source.labor_doc_rows(doc)
files = doc_b09.attach({"일위대가.json": rows, "단가.json": source.price_bundle(rows, me)})
made = files[doc_b09.FILE]
assert made["그룹"] == "수식문서" and PCT in made["문서"]
assert doc_b09.FILE in snap.source_files(files)
assert doc_b09.attach(files) is files # 이미 있음 = 그대로
_fake(monkeypatch, [_changed(_live().logic(PCT))])
again = doc_b09.build(source.price_bundle(rows, me), rows)
assert again["문서"][PCT] == made["문서"][PCT] # 일위대가 수식 사본 = 만든 때
def _session(role="USER"):
return {"role": role, "company_id": 7, "user_id": 42}
def test_permission_layer(world):
"""⑧ 읽기 = 층 읽기 · 미리 셈 · 저장 = 층 쓰기(마스터 = 시스템 관리자 · 회사 = 회사 관리자)."""
me = world["personal"]
key = _sk(me, 바탕={"로직": PCT})
body = router.DocBody(문서=_at(me, path.read, key)["문서"])
for layer in ("system", "company"):
for fn in (router.preview_doc, router.save_doc):
with pytest.raises(HTTPException) as e:
fn(layer, key, body, None, _session())
assert e.value.status_code == 403
assert router.read_doc("personal", key, None, _session())["셈"]["셈됨"]
got = router.preview_doc("personal", key, body, None, _session())
assert got["후"] == got["전"]
def test_delete_tolerant_and_blank(world):
"""⑨ 무엇을 지워도 오류 없음 — 변수 지움 = 정의 필요 · 금액 「—」 · 저장됨 · 빈 SK = 「—」."""
me = world["personal"]
key = _sk(me, 바탕={"로직": PCT})
read = _at(me, path.read, key)
gone = copy.deepcopy(read["문서"])
gone["변수"] = [v for v in gone["변수"] if v["열쇠"] != "w_지붕잇기공"]
pre = _at(me, path.preview, key, {"문서": gone})
assert pre["셈"]["셈됨"] is False and pre["후"] is None
assert any(m["갈래"] == "정의 필요" for m in pre["셈"]["표지"])
_at(me, path.save, key, {"문서": gone, "판": read["판"]})
got = _calc(me, _doc(me, key))
assert got["기준"] is None and got["수식셈"]["셈됨"] is False
lost = copy.deepcopy(read["문서"])
lost["변수"].append({"열쇠": "b", "기호": "b", "연결": {"갈래": "단가산출", "키": "GC999999"}})
lost["금액"].append({"이름": "없는 기초", "비목": "묶음", "단가": "b"})
pre = _at(me, path.preview, key, {"문서": lost})
assert any(m["갈래"] == "연결 끊김" for m in pre["셈"]["표지"])
for bad in ({"문서": "글"}, {"문서": {"금액": "x"}}, {"끊음": []}, {"할일": "몰라"}):
with pytest.raises(store.StoreError) as e:
_at(me, path.preview, key, bad)
assert e.value.status == 400
empty = _sk(me)
got = _calc(me, _doc(me, empty))
assert got["기준"] is None and "빈 문서" in got["수식셈"]["까닭"]