Files
Aislo/resources/tester/test_822_1_copy_gap.py
T
eomsangdonandClaude Opus 5.5 c4050ccf73 feat(859-2 ㉯): M02 단가산출 M01 따라옴 알림 = 토스트 한 번 — [확인] 창 · 머리 띠 · 배지 걷음
- 화면: 열 때 알림 창(표 · [위 값으로] · [확인] · [나중에]) → 토스트 「M01 기초가 바뀌어 반영됨」(+ 「내가 고친 칸 n 은 내 값 그대로」 · 「다시 못 얹은 내 고침 n」) · 확인 단추 없음
- 되풀이 막기: 서버 읽기 답 `사본.따라옴` = 저장본 대 지금 사본의 M01 몫 지문(값 판 · 부른 문서 · 바탕 판 · 문서 계산 내용 · 같으면 null) ·
  화면 localStorage(SK 길마다 {따라옴 지문, 알림 글}) — 새 지문 · 새 알림일 때만 · [저장] 하면 지문 없음
- 머리 띠 「바탕 단가산출 기초가 저장 뒤 바뀜」 · 배지 「M01 개정 — 확인」 · 「지워짐 n」 배지 걷음 · 글 키 걷음
- 서버: [확인] 저장 할일 `갱신확인`(`renew.CONFIRM` · form/_covers/_soft confirm 갈래) · 수식 길 `할일` 칸 걷음 ·
  읽기 답 바뀜 표지(M01새판 · 지운키 · 단가새값 · 문서새판 · 자동 = 열 때마다 dc.state 셈) 걷음
- 자동 반영 · 내 고친 칸 지킴(파란 테두리 · 풍선 「원래 값」) 그대로
- 시험: 836_2 ㉧ 토스트 지문(만든 뒤 없음 · 바뀜 = 같은 지문 · 저장 뒤 없음 · 또 바뀜 = 다른 지문) · 848_10 따로 문서 옵션 따라옴 = 지문 ·
  확인 저장 단언은 [저장] 꼴로 · test_confirm_clears 지움 · 읽기 답 표지 단언 걷음 · 856_0 띠 = 빠진 줄만

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 23:34:39 +09:00

236 lines
10 KiB
Python

# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""822-1 사본 빈틈 막기(요구 797-1) — 길마다: 만들기 → [저장] → M01 값(임시 · 메모리 덮개)을
기계 가격 · 노임 · 유가 · 자재 값으로 바꿈 → 금액 그대로(859-2 [단가 갱신] · 바뀜 표지 걷음).
길 = 수식 길 줄 쌓기(품셈 기계 · 바꿔 끼운 기계 · 자원 줄 · 단가산출 참조) ·
옛 로직 길(더한줄 로직 · 재료 · 인력) · 가져온 식(단가기준 우리) · 층 복사 ·
빈틈 SK(지금 값으로 셈 · 저장하면 굳음).
M01 바꿈 = `skc.Copy` 아닌 진짜 색인 사본(`dc.base` 가 못 벗김) · 정본 파일 안 고침.
"""
from __future__ import annotations
import copy
import json
import pytest
from M01_MasterData import M01_MasterData_Store as m01
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 # 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)
DIG, DIG_NO, DIG_LOGIC = "EQ000022", "0201-0100", "GC000267" # 굴착기(무한궤도) 1.0㎥
DIG2_NO = "0201-0070" # 바꿔 끼울 굴착기
MAN = "LB000002" # 보통인부
PCT = "GC001109" # 금속기와 해체(인력 둘 + 노무비 3 %)
def _live():
return m01.loaded()[1]
def _move(monkeypatch, *keys: str) -> None:
"""M01 값 두 배 — 키마다 값 칸(기계 = 가격 · 자재 = 물가 칸) · 진짜 색인 사본(Copy 아님) ·
수식 문서 폴더 그대로."""
files, live = m01.loaded()
fake = copy.copy(live)
fake.index, fake.numbers = dict(live.index), dict(live.numbers)
for key in keys:
tid = key[:2]
row = copy.deepcopy(live.index[tid][key])
if tid == "EQ":
row["값"]["가격"] *= 2
elif tid == "MT":
for k in ("물가자료", "유통물가", "물가정보", "거래가격"):
row[k] = row[k] * 2 if row.get(k) else row.get(k)
else:
row["값"] *= 2
fake.index[tid] = {**fake.index[tid], key: row}
if row.get("원문번호"):
fake.numbers[tid] = {**fake.numbers[tid], str(row["원문번호"]): row}
monkeypatch.setattr(m01, "loaded", lambda: (files, fake))
def _at(folder, fn, *args):
with store.at(folder):
return fn(*args)
def _sk(folder, **body) -> str:
body = {"이름": "sub1임시 빈틈", "단위": "시간", "더한줄": [], **body}
return _at(folder, lambda: refs.create("sangeun", body)["이름"])
def _var(sym: str, link: dict, name: str = "") -> dict:
return {"기호": "P", "아래": sym, "위": "", "이름": name or sym, "단위": "", "연결": link}
def _line(sym: str, part: str = "경비") -> dict:
return {"이름": sym, "단위": "hr", "비목": part, "수량": "1", "단가": f"P_{sym}"}
def _stack(folder, key, rows: list[tuple[str, dict, str]]) -> None:
"""줄 쌓기 — 지금 문서에 (기호, 연결, 비목) 줄을 더해 수식 길로 저장."""
got = _at(folder, path.read, key)
doc = copy.deepcopy(got["문서"])
doc.setdefault("변수", []).extend(_var(s, link) for s, link, _ in rows)
doc.setdefault("금액", []).extend(_line(s, part) for s, _, part in rows)
_at(folder, path.save, key, {"문서": doc, "판": got["판"]})
def _sum(folder, key):
return _at(folder, path.read, key)["셈"]["계"]
MACHINE = {"갈래": "단가산출", "키": DIG_LOGIC, "입력": {"기계": f"'{DIG_NO}'"}}
def _fuel_and_crew(no: str = DIG_NO) -> tuple[str, str]:
"""기계 시간당 식이 읽는 유가(MO) · 조종원 노임(LB) 키."""
w = _live()
row = w.numbers["EQ"][no]
fuel = w.numbers["MO"][f"{row['값']['주연료종류']}:전국평균"]["키"]
crew = w.numbers["LB"][row["값"]["인력"][0]["키"].removeprefix("LB:")]["키"] # 842-3 인력 줄
return fuel, crew
# ── 수식 길 줄 쌓기 ───────────────────────────────────────────────────
@pytest.mark.parametrize("what", ["가격", "유가", "노임"])
def test_stack_m01_machine(world, monkeypatch, what):
"""품셈 기계(굴착기 1.0㎥) 줄 쌓기 → 저장 → 기계 가격 · 유가 · 조종원 노임 바뀜 →
금액 그대로."""
me = world["personal"]
key = _sk(me)
_stack(me, key, [("기계", MACHINE, "묶음")])
was = _sum(me, key)
assert was > 0
fuel, crew = _fuel_and_crew()
moved = {"가격": DIG, "유가": fuel, "노임": crew}[what]
_move(monkeypatch, moved)
now = _at(me, path.read, key)
assert now["셈"]["계"] == was
def test_stack_swapped_machine(world, monkeypatch):
"""바꿔 끼운 기계 — 기계 입력을 다른 굴착기로 바꿔 저장 → 그 기계 값이 사본에."""
me = world["personal"]
key = _sk(me)
_stack(me, key, [("기계", MACHINE, "묶음")])
got = _at(me, path.read, key)
doc = copy.deepcopy(got["문서"])
for v in doc["변수"]:
if (v.get("연결") or {}).get("키") == DIG_LOGIC:
v["연결"]["입력"] = {"기계": f"'{DIG2_NO}'"}
_at(me, path.save, key, {"문서": doc, "판": got["판"]})
was = _sum(me, key)
other = _live().numbers["EQ"][DIG2_NO]["키"]
_move(monkeypatch, other)
assert _sum(me, key) == was
@pytest.mark.parametrize("kind", ["인력", "재료"])
def test_stack_resource(world, monkeypatch, kind):
"""자원 줄 더하기(노임 · 자재 요소) — 저장 뒤 값 바뀌어도 그대로."""
me = world["personal"]
res = MAN if kind == "인력" else next(iter(_live().index["MT"]))
key = _sk(me)
part = "노무비" if kind == "인력" else "재료비"
_stack(me, key, [("자원", {"갈래": "요소", "키": res}, part)])
was = _sum(me, key)
assert was > 0
_move(monkeypatch, res)
assert _sum(me, key) == was
def test_stack_logic_ref(world, monkeypatch):
"""단가산출 참조(M01 단가산출을 부름) — 그 식이 읽는 노임도 사본에."""
me = world["personal"]
key = _sk(me)
_stack(me, key, [("참조", {"갈래": "단가산출", "키": PCT, "입력": {}}, "묶음")])
was = _sum(me, key)
assert was > 0
_move(monkeypatch, MAN)
assert _sum(me, key) == was
# ── 옛 로직 길(더한줄 · 파생) ────────────────────────────────────────
OLD_ADDS = {
"로직 기계": ([{"종류": "로직", "로직": DIG_LOGIC, "입력값": {"기계": DIG_NO}, "수량": 1}],
{"기계": DIG_NO}, DIG),
"재료 요소": ([{"종류": "재료", "요소": "MT000008", "수량": 1}], {}, "MT000008"),
"인력 요소": ([{"종류": "인력", "요소": MAN, "수량": 1}], {}, MAN),
} # fmt: skip
# ── 가져온 식 · 층 복사 · 재생성 ──────────────────────────────────────
def test_imported_ours(world, monkeypatch):
"""가져온 식 단가기준 우리 — 이음 노임 바뀌어도 그대로 · 갱신 뒤 반영 · 엑셀 기준 = 엑셀 값."""
from M02_MasterTemplete import M02_Sangeun_Imported as imp
me = world["personal"]
man = {"종류": "인력", "이름": "보통인부", "단위": "인", "수량": "0.5", "비목": "노무비"}
row = {
"이름": "sub1임시 가져온",
"결과단위": "원/㎡",
"호표": [{**man, "단가": 165545, "이음": MAN}],
}
key = _at(me, lambda: imp.create(row, None, "sub1임시 가져온")["이름"])
assert _sum(me, key) == 82772 # 엑셀 단가 그대로
doc = _at(me, lambda: store.read("sangeun", key)["문서"])
ours = _at(me, lambda: imp.to_price(doc, "우리")["문서"])
_at(me, lambda: store.write("sangeun", key, store.read("sangeun", key)["판"], ours))
was = _sum(me, key)
_move(monkeypatch, MAN)
assert _sum(me, key) == was
def test_layer_copy_keeps_copy(world, monkeypatch):
"""층 복사(개인 → 회사) — 줄 쌓기 기계 사본째 · 원본 M01 값 바뀐 뒤 복사해도 그 값."""
me, co = world["personal"], world["company"]
key = _sk(me)
_stack(me, key, [("기계", MACHINE, "묶음")])
was = _sum(me, key)
_move(monkeypatch, DIG)
ref = {"층": "personal", "주인": "7/42", "키": key}
with store.at(co):
doc = refs.read_ref(ref)
new = refs.create("sangeun", refs.carry(refs.origin_mark(doc, ref), ("personal", "7/42")))
assert _sum(co, new["이름"]) == was
def test_gap_mark_then_save_fills(world, monkeypatch):
"""빈틈 있는 옛 SK — 열면 지금 값으로 셈 · 일괄 고쳐 쓰지 않음 ·
[저장] 하면 지금 값으로 굳음 · 그 뒤 M01 바뀌어도 그대로."""
me = world["personal"]
key = _sk(me)
_stack(me, key, [("기계", MACHINE, "묶음")])
file = me / "sangeun" / f"{key}.json"
raw = json.loads(file.read_text(encoding="utf-8"))
vals = raw["문서"]["수식"] if "문서" in raw else raw["수식"]
for part in ("로직", "단가"):
vals[part] = [] # 옛 저장본 흉내 — 줄 쌓기 기계를 사본에 안 박은 때
file.write_text(json.dumps(raw, ensure_ascii=False), encoding="utf-8")
before = file.read_bytes()
was = _sum(me, key)
assert file.read_bytes() == before # 열기 = 안 고쳐 씀
files, live = m01.loaded()
_move(monkeypatch, DIG)
moved = _sum(me, key)
assert moved > was # 빈틈 = 지금 값으로 셈
got = _at(me, path.read, key)
_at(me, path.save, key, {"문서": got["문서"], "판": got["판"]})
assert _sum(me, key) == moved
monkeypatch.setattr(m01, "loaded", lambda: (files, live)) # 앞 값(절반)
assert _sum(me, key) == moved