- `Sangeun_Calc.run` = 수식 사본 문서 셈 답으로 답 꼴 채움(기준 · 1단위 · 배 · 줄 cid 「금액#n」 · 단위 · 끝수 · 까닭 · 수식셈 · 바탕판 · 꼬리표) · 빠진줄 · 짝잃음 = 빈 목록(옛 칸 개념) - 수식 사본 없는 SK(바탕 참조) · 옛 칸 고침 파생 SK(덮개 · 뺀줄 · 더한줄 · 수식고침 · 식 칸) = 못 셈 + 까닭 하나(올림 없음) · `sub_run`(둘째 기초) 도 못 셈 - 굳힌 사본 SK(B09 · 구조물 사본 GX9 · 수식 없음) = 옛 길 그대로(`_frozen` · B9 걸음 몫) - `Doc_Sk.derive` = 옛 엔진 ctx 없이 기초 문서 사본 + 줄 규칙(입력값 · 켜쌓기율 · 고름 · 자재표시) · `copy_of(sk, whole)` · `on_run` 걷음 · 저장 `settle` = 옛 셈 안 돎 · 저장 관문 읽은 줄 = 문서 셈 + 부름 줄(826-3) · 저장 전 새 SK = 지금 M01 값 · 열린 목록 · 내 기계 고른 값 = 목록에 더함 - `Doc_Sk_Path.current` · `Labor_Copy.line`(사본 있으면 문서만) · `Doc_Import._old_ctx` 걷음(엔진 더한줄 = 못 셈) · `Sangeun_Const.answer` 보기 덧칸 없음 - 층 서고 SK 14 전후: 기준 · 1단위 · 배 · 까닭 · 바탕판 다름 0 · 줄 합 = 기준 11/14 → 14/14 · 「따로」 줄 0 → 4 · 한 번 셈 run_line 14 → 0(저장 25 → 0) - 시험: test_855_sk_layers 「따로」 단언 뒤집음(줄 합 = 기준 · 줄 > 0 · 옛 엔진 부름 0 · 옛 칸 = 못 셈) · golden_855_b09 다시 뜸(daega_inputs — 「율 더한줄」 SK = 옛 칸 = 못 셈 → 그 블록 m02 없음 · 그 밖 같음) - 지운 시험(옛 칸 셈만 붙듦 — 덮개 · 뺀줄 · 더한줄 · 율 더한줄 · 수식고침 · 식 칸 · 상수 · 표값 덮개 · 넣은 SK 몸 · 줄 패치 · 보기 글 · 옵션꺼짐 줄): 715_sangeun_engine · 717_2b · 725_1 · 744_1 · 750_1 파일 · 715_3 셋 · 715_store 다섯 · 727 넷 · 728_2 하나 · 740_1 일곱 · 742_1 하나 · 753_1 하나 · 778_4 여섯 · 790_2 다섯 · 792_1 일곱 · 792_2 하나 · 795_1 하나 · 795_2 하나 · 796_2b 셋 · 822_1 하나 · logic_mats 둘(일위대가 옛 로직 줄 재료 목록 — 사본 셈 = 문서) - 고친 시험(살아 있는 결과): 728_2 금액 = 수식 문서 기본 옵션 · 747_1 줄 이름 · 별도계상 합밖 · 721 일위대가 쪽만 · 793_2 옛 시트 같음 단언 둘 뺌 · 795_1 노임 키 = 값 사본 · 802_4a · 802_4b2 부름 = 기초 문서가 부르는 단가산출(GC000006) · 811_1 모달 저장 = 수식 길 · 821_1 · 822_2 · 778_2 = 바탕 로직 + 입력값 · 826_3 저장 셈 1 → 0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
202 lines
8.5 KiB
Python
202 lines
8.5 KiB
Python
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
|
"""795-1 SK 로직 사본 — 저장 때 M01 닫힌 묶음을 찍고 셈은 사본으로(임시 storage · M01 은 메모리 덮개).
|
|
|
|
① M01 로직 줄 바꿔도 사본 SK 금액 그대로 ② 노임 바꿔도 [단가 갱신] 전엔 그대로 · 누르면 따라감
|
|
③ [재생성] 뒤 고친 칸 다시 얹힘 · 못 얹은 칸 알림 ④ M01 새 판 배지 ⑤ 지워진 키 = 마지막 값
|
|
⑥ 옛 SK(사본 없음) = 옛 길 · 지문 그대로 ⑦ 가져온 식 SK 같은 규칙.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import copy
|
|
import json
|
|
|
|
import pytest
|
|
|
|
from M01_MasterData import M01_MasterData_Store as m01
|
|
from M02_MasterTemplete import M02_Labor_Doc as labor
|
|
from M02_MasterTemplete import M02_Labor_Ref as refs
|
|
from M02_MasterTemplete import M02_Library_Same as same
|
|
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
|
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
|
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
|
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
|
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)
|
|
|
|
|
|
PCT = "GC001109" # 원/㎡ · 인력 둘 + 「노무비 * 3 / 100」
|
|
MAN = "LB000002" # 보통인부
|
|
|
|
|
|
def _live():
|
|
return m01.loaded()[1]
|
|
|
|
|
|
def _fake(monkeypatch, rows=(), drop=()):
|
|
"""M01 바꿈 흉내 — 지금 색인 위에 바뀐 줄 · 지운 키(정본 파일 안 고침) · M01 수식 문서도 같이
|
|
(802-4a — 수식 사본 SK 의 M01 정본 = 수식 문서 · 바뀐 줄은 그 줄 변환 문서로)."""
|
|
from M02_MasterTemplete import M02_Doc_Copy as dc
|
|
|
|
files, live = m01.loaded()
|
|
fake = skc.Copy(live, [copy.deepcopy(r) for r in rows])
|
|
for key in drop:
|
|
skc.Copy._own(fake.index, live.index, key[:2]).pop(key, None)
|
|
monkeypatch.setattr(m01, "loaded", lambda: (files, fake))
|
|
docs = {k: v for k, v in dc.folder().items() if k not in drop}
|
|
docs |= {str(r["키"]): dc.cv.convert(fake, copy.deepcopy(r))[0] for r in rows if "호표" in r}
|
|
monkeypatch.setattr(dc, "folder", lambda: docs)
|
|
return fake
|
|
|
|
|
|
def _sk(folder, **doc):
|
|
with store.at(folder):
|
|
body = {"이름": "sub2임시 사본", "단위": "㎡", "더한줄": [], **doc}
|
|
return refs.create("sangeun", body)["이름"]
|
|
|
|
|
|
def _doc(folder, key):
|
|
with store.at(folder):
|
|
return store.read("sangeun", key)["문서"]
|
|
|
|
|
|
def _save(folder, key, doc):
|
|
with store.at(folder):
|
|
store.write("sangeun", key, store.read("sangeun", key)["판"], doc)
|
|
|
|
|
|
def _calc(folder, doc):
|
|
with store.at(folder):
|
|
return calc.calc_doc(doc, None, False)
|
|
|
|
|
|
def _sum(folder, key):
|
|
return _calc(folder, _doc(folder, key))["기준"]["계"]
|
|
|
|
|
|
def _changed(row, at=0):
|
|
row = copy.deepcopy(row)
|
|
row["호표"][at]["수량"] = f"({row['호표'][at]['수량']}) * 2"
|
|
return row
|
|
|
|
|
|
def test_copy_stamped_and_logic_change_kept(world, monkeypatch):
|
|
"""① · ④ 저장 때 사본(로직 · 단가 갈래) · M01 로직 바꿔도 금액 그대로 · 배지만."""
|
|
me = world["personal"]
|
|
key = _sk(me, 바탕={"로직": PCT})
|
|
got = _doc(me, key)["사본"]
|
|
assert PCT in {r["키"] for r in got["로직"]}
|
|
assert got["단가"] and all(r["키"][:2] in skc.RES for r in got["단가"])
|
|
assert not any(r["키"][:2] in skc.RES for r in got["로직"])
|
|
first = _calc(me, _doc(me, key))
|
|
assert first["사본"]["M01새판"] is False and first["사본"]["지운키"] == []
|
|
was = first["기준"]["계"]
|
|
plain = labor.run_line(_live(), PCT, {})["기준"]["계"]
|
|
_fake(monkeypatch, [_changed(_live().logic(PCT))])
|
|
assert labor.run_line(m01.loaded()[1], PCT, {})["기준"]["계"] != plain # M01 셈은 바뀜
|
|
now = _calc(me, _doc(me, key))
|
|
assert now["기준"]["계"] == was
|
|
assert now["사본"]["M01새판"] is True
|
|
|
|
|
|
def test_price_refresh_only_on_press(world, monkeypatch):
|
|
"""② 노임 바꿈 → 그대로 · [단가 갱신] 미리 셈 · 저장 = 새 SK 와 같은 값 · 바뀐자원."""
|
|
me = world["personal"]
|
|
key = _sk(me, 바탕={"로직": PCT})
|
|
was = _sum(me, key)
|
|
lb = next(r["키"] for r in _doc(me, key)["사본"]["단가"] if r["키"].startswith("LB"))
|
|
row = copy.deepcopy(_live().get(lb))
|
|
row["값"] = row["값"] * 2
|
|
_fake(monkeypatch, [row])
|
|
assert _sum(me, key) == was # 누르기 전 = 단가 기준 시점 값
|
|
fresh = _sum(me, _sk(me, 바탕={"로직": PCT})) # 지금 M01 로 새로 찍은 SK
|
|
assert fresh != was
|
|
with store.at(me):
|
|
got = skc.preview(_doc(me, key), skc.PRICE)
|
|
assert got["전"]["계"] == was and got["후"]["계"] == fresh
|
|
assert [x["키"] for x in got["바뀐자원"]] == [lb]
|
|
assert got["문서"][skc.JOB] == skc.PRICE
|
|
_save(me, key, got["문서"]) # [저장] = 서버가 할일 적용
|
|
saved = _doc(me, key)
|
|
assert skc.JOB not in saved and _sum(me, key) == fresh
|
|
assert saved["사본"]["단가시점"] >= saved["사본"]["시점"]
|
|
|
|
|
|
def test_deleted_keys_keep_last_value(world, monkeypatch):
|
|
"""⑤ 사본이 부르는 M01 키(바탕 로직 · 노임)가 지워져도 마지막 값 · 지운키 표지."""
|
|
me = world["personal"]
|
|
key = _sk(me, 바탕={"로직": PCT})
|
|
was = _sum(me, key)
|
|
lb = next(r["키"] for r in _doc(me, key)["사본"]["단가"] if r["키"].startswith("LB"))
|
|
_fake(monkeypatch, drop=[PCT, lb])
|
|
with pytest.raises(Exception):
|
|
m01.loaded()[1].logic(PCT)
|
|
now = _calc(me, _doc(me, key))
|
|
assert now["기준"]["계"] == was
|
|
assert {PCT, lb} <= set(now["사본"]["지운키"])
|
|
with store.at(me):
|
|
got = skc.preview(_doc(me, key), skc.PRICE)
|
|
assert {"키": lb, "이름": got["바뀐자원"][0]["이름"], "지워짐": True} in got["바뀐자원"]
|
|
assert got["후"]["계"] == was
|
|
|
|
|
|
def test_old_sk_without_copy_old_path(world, monkeypatch):
|
|
"""⑥ 사본 없는 옛 SK = M01 지금 값(옛 길) · 같은 내용 지문 = 새 사본 SK 와 같음."""
|
|
me = world["personal"]
|
|
key = _sk(me, 바탕={"로직": PCT})
|
|
path = me / "sangeun" / f"{key}.json"
|
|
raw = json.loads(path.read_bytes())
|
|
old = {k: v for k, v in raw.items() if k not in ("사본", "수식")} # 795 앞 SK = 둘 다 없음
|
|
path.write_text(json.dumps(old, ensure_ascii=False), encoding="utf-8")
|
|
fresh = _sk(me, 바탕={"로직": PCT})
|
|
assert _sum(me, key) == _sum(me, fresh)
|
|
assert "사본" not in _calc(me, _doc(me, key))
|
|
with store.at(me):
|
|
assert same.Same().finger("sangeun", old) == same.Same().finger("sangeun", _doc(me, fresh))
|
|
_fake(monkeypatch, [_changed(_live().logic(PCT))])
|
|
moved = labor.run_line(m01.loaded()[1], PCT, {})["기준"]["계"]
|
|
assert _sum(me, key) == pytest.approx(moved, abs=1) # 옛 길 = 따라감
|
|
assert _sum(me, fresh) != _sum(me, key) # 사본 SK = 그대로
|
|
with store.at(me): # 판 다른 두 SK = 지문 다름(오판 막음)
|
|
assert same.Same().finger("sangeun", _doc(me, key)) != same.Same().finger(
|
|
"sangeun", _doc(me, fresh)
|
|
)
|
|
|
|
|
|
def _imported_row():
|
|
man = {"종류": "인력", "이름": "보통인부", "단위": "인", "수량": "0.5", "비목": "노무비"}
|
|
mat = {"종류": "재료", "이름": "각재", "단위": "㎥", "수량": "0.01", "비목": "재료비"}
|
|
return {
|
|
"이름": "sub2임시 가져온",
|
|
"결과단위": "원/㎡",
|
|
"호표": [{**man, "단가": 165545, "이음": MAN}, {**mat, "단가": 500661}],
|
|
}
|
|
|
|
|
|
def test_imported_same_rule(world, monkeypatch):
|
|
"""⑦ 가져온 식 SK(단가기준 우리) — 이음 노임 바꿔도 그대로 · [단가 갱신] 뒤 따라감."""
|
|
me = world["personal"]
|
|
with store.at(me):
|
|
key = imp.create(_imported_row(), None, "sub2임시 가져온")["이름"]
|
|
doc = _doc(me, key)
|
|
assert MAN in {r["키"] for r in doc["사본"]["단가"]}
|
|
with store.at(me):
|
|
ours = imp.to_price(doc, "우리")["문서"]
|
|
_save(me, key, ours)
|
|
was = _sum(me, key)
|
|
row = copy.deepcopy(_live().get(MAN))
|
|
row["값"] = row["값"] * 2
|
|
_fake(monkeypatch, [row])
|
|
assert _sum(me, key) == was
|
|
with store.at(me):
|
|
got = skc.preview(_doc(me, key), skc.PRICE)
|
|
assert [x["키"] for x in got["바뀐자원"]] == [MAN]
|
|
assert got["후"]["노무비"] == pytest.approx(got["전"]["노무비"] * 2, abs=1)
|