Files
Aislo/resources/tester/test_848_2_cover_renew.py
T
eomsangdonandClaude Opus 5.5 5673998971 feat(848-2): Doc_Sk 세 줄 — 원본 판 = 계산 내용 지문 · 파생 저장에 맡긴 칸 실음 · 알림 [확인] 때 바탕 걷음
- 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>
2026-11-16 21:05:28 +09:00

302 lines
14 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 에서 받아 씀
"""848-2 갱신 칸 단위(요구서_889 3 절) — 임시 storage + M01 메모리 사본(정본 파일 안 고침).
㉠ 기계 가격만 바뀜 + 인력 고침 = 가격 따라옴 · 인력 고침 남음 · 알림 없음
㉡ 기계 가격 바뀜 + 가격 고침 = 내 값 지킴 + 알림(전 → 후 · 내 값) · 금액 그대로
㉢ 기계 비고 · 출처 글만 바뀜 = 고침 그대로 · 알림 없음
㉣ 기초 고침(①)만 바뀜 = 따로 문서 · 끊음 안 지워짐 · ① 이 내 고침 칸을 바꾸면 지킴 알림(층 기초)
㉤ 기초에 줄이 더해짐 = 다시 복사 + 알림 자료 · 기계 고침 · 옵션 값 다시 얹힘
㉥ 확인 전 [저장] = 바탕 남아 알림 계속 · 확인 뒤 = 안 뜸
㉦ 프로젝트 사본 = 그대로 ㉧ 내 기계 · 가져온 식 = 같은 규칙.
"""
from __future__ import annotations
import copy
import shutil
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 M02_MasterTemplete import M02_MyMachine as mym
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
from resources.tester.test_822_1_copy_gap import DIG, DIG_NO, MACHINE, _at, _move, _sk, _stack
from resources.tester.test_836_2_sk_auto_renew import _cover, _doc_move
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
CUT = (
"GC000085" # 흙깎기(기계) 보통토사 — 굴착기 1.0㎥(0201-0100) 부름 · 옵션 규모 · 지역 · 보정작업
)
PRICE = 142069 # 굴착기 1.0㎥ M01 가격
def _eq_move(monkeypatch, key: str, fn) -> None:
"""M01 기계 줄 하나 고침(메모리 · 진짜 색인 사본)."""
files, live = m01.loaded()
fake = copy.copy(live)
fake.index, fake.numbers = dict(live.index), dict(live.numbers)
row = copy.deepcopy(live.index["EQ"][key])
fn(row)
fake.index["EQ"] = {**fake.index["EQ"], key: row}
fake.numbers["EQ"] = {**fake.numbers["EQ"], str(row["원문번호"]): row}
monkeypatch.setattr(m01, "loaded", lambda: (files, fake))
def _read(me, key):
return _at(me, path.read, key)
def _machine_sk(me, cover: dict) -> str:
key = _sk(me)
_stack(me, key, [("기계", MACHINE, "묶음")])
_cover(me, key, {DIG_NO: cover})
return key
def _cut_sk(me, size: str = "소규모", cover: dict | None = None) -> str:
"""흙깎기 바탕 SK — 규모 옵션 고침(소규모 = 굴착기 줄 셈) · ② 기계 고침 · 따로 저장."""
key = _sk(me, 바탕={"로직": CUT}, 단위="㎥")
got = _read(me, key)
doc = copy.deepcopy(got["문서"])
for v in doc["변수"]:
if v.get("열쇠") == "규모":
v["연결"]["값"] = size
if cover:
doc["기계덮음"] = {DIG_NO: cover}
_at(me, path.save, key, {"문서": doc, "판": got["판"]})
return key
def _size(doc: dict) -> str:
return next(v["연결"]["값"] for v in doc["변수"] if v.get("열쇠") == "규모")
def test_price_follows_crew_kept(world, monkeypatch):
"""㉠ 가격만 바뀜 + 인력 고침 = 가격 따라옴 · 인력 고침 남음 · 알림 없음."""
me = world["personal"]
crew = {"조종원": [{"키": "LB:1048", "인": 2}]}
key = _machine_sk(me, crew)
was = _read(me, key)
assert was["문서"]["기계덮음"] == {DIG_NO: crew}
_move(monkeypatch, DIG)
got = _read(me, key)
assert got["문서"]["기계덮음"] == {DIG_NO: crew} and got["사본"]["갱신"] == []
assert got["셈"]["계"] > was["셈"]["계"]
def test_price_kept_with_note(world, monkeypatch):
"""㉡ 가격 바뀜 + 가격 고침 = 내 값 지킴 + 알림(전 → 후 · 내 값 · 칸 경로) · 금액 그대로 ·
읽기 = 파일 안 씀."""
me = world["personal"]
key = _machine_sk(me, {"값": {"가격": 150000}})
was = _read(me, key)
file = me / "sangeun" / f"{key}.json"
before = file.read_bytes()
_move(monkeypatch, DIG)
got = _read(me, key)
assert got["문서"]["기계덮음"] == {DIG_NO: {"값": {"가격": 150000}}}
assert got["셈"]["계"] == was["셈"]["계"]
[note] = got["사본"]["갱신"]
assert {k: note[k] for k in ("키", "갈래", "처리", "열쇠", "경로", "층")} == {
"키": DIG, "갈래": "기계", "처리": "지킴", "열쇠": DIG_NO, "경로": "값.가격", "층": "기계",
} # fmt: skip
assert (note["전"], note["후"], note["내값"]) == (PRICE, PRICE * 2, 150000)
assert note["M01"] == [f"가격 {PRICE} → {PRICE * 2}"] and note["내고침"] == ["가격 150000"]
assert file.read_bytes() == before
def test_label_only(world, monkeypatch):
"""㉢ 비고 · 출처 글만 바뀜 = 고침 그대로 · 알림 없음 · 금액 같음."""
me = world["personal"]
key = _machine_sk(me, {"값": {"가격": 150000}, "조종원": [{"키": "LB:1048", "인": 2}]})
was = _read(me, key)
def label(row: dict) -> None:
row["비고"] = "848-2 시험 비고"
row["출처"] = {**row["출처"], "가격": "848-2 시험 출처"}
row["이름"] = row["이름"] + " 새 이름"
_eq_move(monkeypatch, DIG, label)
got = _read(me, key)
assert got["문서"]["기계덮음"] == was["문서"]["기계덮음"] and got["사본"]["갱신"] == []
assert got["셈"]["계"] == was["셈"]["계"]
def test_crew_list_kept(world, monkeypatch):
"""㉡ 목록 칸 — 인력 줄 바뀜 + 인력 고침 = 지킴 알림(목록 글) · 가격 칸 알림 없음."""
me = world["personal"]
mine = [{"키": "LB:1048", "인": 2}]
key = _machine_sk(me, {"값": {"가격": 150000}, "조종원": mine})
_eq_move(monkeypatch, DIG, lambda r: r["값"].update(인력=[{"키": "LB:1048", "인": 1.5}]))
[note] = _read(me, key)["사본"]["갱신"]
assert (note["경로"], note["처리"], note["내값"]) == ("조종원", "지킴", mine)
assert note["M01"] == ["인력 LB:1048 1인 → LB:1048 1.5인"]
def test_upper_only(world, monkeypatch):
"""㉣ 기초 고침(①)만 바뀜(+ 이름) = 따로 문서 그대로 · ① 이 내 고침 칸을 바꿈 = 지킴(층 기초) ·
② 없는 칸(주연료)은 알림 없음."""
me = world["personal"]
key = _cut_sk(me, cover={"값": {"가격": 150000}})
was = _read(me, key)
assert was["사본"]["따로"] is True
def upper(d: dict) -> None:
d["기계덮음"] = {DIG_NO: {"값": {"가격": 200000, "주연료": 30}}}
d["이름"] = d["이름"] + " 새 이름"
_doc_move(monkeypatch, CUT, upper)
got = _read(me, key)
assert got["사본"]["따로"] is True and _size(got["문서"]) == "소규모"
assert got["문서"]["기계덮음"] == {DIG_NO: {"값": {"가격": 150000}}}
[note] = got["사본"]["갱신"]
assert (note["경로"], note["층"], note["전"], note["후"]) == ("값.가격", "기초", PRICE, 200000)
assert got["셈"]["계"] > was["셈"]["계"] # 안 고친 칸(주연료 ①) = 따라옴 · 가격 = 내 값
assert not got["사본"]["문서새판"]
def test_cut_kept_on_upper(world, monkeypatch):
"""㉣ 끊음 — 부른 문서의 ① · 글만 바뀜 = 끊음 그대로 · 계산 내용이 바뀜 = 다시 복사 + 알림."""
me = world["personal"]
key = _sk(me)
_stack(me, key, [("기계", MACHINE, "묶음")])
got = _read(me, key)
call = MACHINE["키"]
mine = copy.deepcopy(got["부름"][call])
mine["금액"][0]["수량"] = f"({mine['금액'][0].get('수량') or 1}) × 2"
_at(me, path.save, key, {"끊음": {call: mine}, "판": got["판"]})
was = _read(me, key)
assert call in was["끊음"]
_doc_move(
monkeypatch, call, lambda d: d.update(기계덮음={DIG_NO: {"값": {"가격": 1}}}, 이름="새")
)
got = _read(me, key)
assert got["끊음"][call]["금액"][0]["수량"] == mine["금액"][0]["수량"]
assert got["사본"]["갱신"] == [] and got["셈"]["계"] == was["셈"]["계"]
_doc_move(monkeypatch, call, lambda d: d["금액"].append(copy.deepcopy(d["금액"][0])))
got = _read(me, key)
assert call not in got["끊음"]
[note] = got["사본"]["갱신"]
assert (note["갈래"], note["처리"]) == ("부름", "지워짐") and note["내고침"]
def _grow(d: dict) -> None:
d["금액"].append({**copy.deepcopy(d["금액"][1]), "이름": "848-2 덧줄"})
def test_structure_recopy(world, monkeypatch):
"""㉤ 기초에 줄 더함 = 다시 복사(따로 아님) · 기계 고침 · 옵션 값 다시 얹음 · 알림 다시복사."""
me = world["personal"]
cover = {"값": {"가격": 150000}}
key = _cut_sk(me, cover=cover)
_doc_move(monkeypatch, CUT, _grow)
got = _read(me, key)
assert got["사본"]["따로"] is False
assert got["문서"]["기계덮음"] == {DIG_NO: cover} and _size(got["문서"]) == "소규모"
assert any(x["이름"] == "848-2 덧줄" for x in got["문서"]["금액"])
[note] = got["사본"]["갱신"]
assert (note["갈래"], note["처리"], note["내고침"]) == ("문서", "다시복사", [])
assert note["다시얹음"] == ["규모 소규모"]
def test_structure_recopy_saved(world, monkeypatch):
"""㉤ 다시 복사한 뒤 알림 [확인](저장) = 기계 고침 · 옵션 값 남음 · 알림 없음."""
me = world["personal"]
cover = {"값": {"가격": 150000}}
key = _cut_sk(me, cover=cover)
_doc_move(monkeypatch, CUT, _grow)
got = _read(me, key)
_at(me, path.save, key, {"할일": renew.CONFIRM, "판": got["판"]})
after = _read(me, key)
assert after["사본"]["갱신"] == [] and after["문서"]["기계덮음"] == {DIG_NO: cover}
assert _size(after["문서"]) == "소규모" and after["셈"]["계"] == got["셈"]["계"]
def test_save_keeps_base(world, monkeypatch):
"""㉥ 확인 전 [저장](고친 문서 다시 저장) = 바탕 남아 알림 계속."""
me = world["personal"]
key = _machine_sk(me, {"값": {"가격": 150000}})
_move(monkeypatch, DIG)
got = _read(me, key)
_at(me, path.save, key, {"문서": got["문서"], "판": got["판"]})
again = _read(me, key)
[note] = again["사본"]["갱신"]
assert (note["전"], note["후"]) == (PRICE, PRICE * 2)
def test_confirm_clears(world, monkeypatch):
"""㉥ 알림 [확인] 뒤 = 안 뜸 · 내 값 그대로 · 금액 같음."""
me = world["personal"]
key = _machine_sk(me, {"값": {"가격": 150000}})
_move(monkeypatch, DIG)
got = _read(me, key)
_at(me, path.save, key, {"할일": renew.CONFIRM, "판": got["판"]})
after = _read(me, key)
assert after["사본"]["갱신"] == [] and after["셈"]["계"] == got["셈"]["계"]
assert after["문서"]["기계덮음"] == {DIG_NO: {"값": {"가격": 150000}}}
def test_project_keeps(world, monkeypatch):
"""㉦ 프로젝트 층 사본 = 그대로(금액 · 고침 · 알림 없음)."""
me = world["personal"]
key = _machine_sk(me, {"값": {"가격": 150000}})
proj = me.parent / "p8482" / "templates"
(proj / "sangeun").mkdir(parents=True)
shutil.copy(me / "sangeun" / f"{key}.json", proj / "sangeun" / f"{key}.json")
with store.at(proj):
assert refs.here()[0] == "project"
was = _read(proj, key)
_move(monkeypatch, DIG)
got = _read(proj, key)
assert got["셈"]["계"] == was["셈"]["계"] and got["사본"]["갱신"] == []
assert got["문서"]["기계덮음"] == was["문서"]["기계덮음"]
def test_my_machine(world):
"""㉧ 내 기계 — 가격 고침 + 내 기계 가격 바뀜 = 지킴 알림."""
me = world["personal"]
vals = {"가격": 1000, "손료계수": 2000, "주연료": 2, "주연료종류": "경유", "잡재료율": 10,
"조종원": 1, "조종원직종": "1048"} # fmt: skip
made = _at(me, mym.create, {"이름": "sub4임시기계", "규격": "1㎾", "방식": "바로", "값": vals})
no, hourly = made["줄"]["원문번호"], made["시간당"]["로직"]
key = _sk(me)
link = {"갈래": "단가산출", "키": hourly, "입력": {"기계": f"'{no}'"}}
_stack(me, key, [("기계", link, "묶음")])
_cover(me, key, {no: {"값": {"가격": 5000}}})
assert _read(me, key)["사본"]["갱신"] == []
_at(me, mym.update, made["줄"]["키"], {"이름": "sub4임시기계", "규격": "1㎾", "방식": "바로",
"값": {**vals, "가격": 3000}}) # fmt: skip
[note] = _read(me, key)["사본"]["갱신"]
assert (note["열쇠"], note["처리"], note["전"], note["후"], note["내값"]) == (
no, "지킴", 1000, 3000, 5000,
) # fmt: skip
def test_imported_same_rule(world, monkeypatch):
"""㉧ 가져온 식 — 같은 칸 판정(① = 저장 `위덮음`) · 알림 지킴."""
me = world["personal"]
key = _machine_sk(me, {"값": {"가격": 150000}})
sk = _at(me, lambda: store.read("sangeun", key)["문서"])
sk = {**sk, "가져온": {"로직": {}}} # 가져온 식 꼴(판정만)
_move(monkeypatch, DIG)
with store.at(me):
[note] = renew.notes(sk)
assert (note["처리"], note["경로"], note["후"]) == ("지킴", "값.가격", PRICE * 2)
def test_upper_cover_keeps_edited_doc(world, monkeypatch):
"""㉣ 기초 문서의 `기계덮음`(①)만 바뀜 = 그 기초로 만든 따로 SK 문서 고침 그대로 · 알림 없음
(문서 지문에서 덮음 뺌 — 848-1 이 남긴 경우)."""
from resources.tester.test_836_2_sk_auto_renew import TOOL, _base, _edit
me = world["personal"]
key = _base(me)
_edit(me, key, "노무비 × 5%")
was = _read(me, key)
_doc_move(monkeypatch, "GC001109", lambda d: d.update(기계덮음={DIG_NO: {"값": {"가격": 1}}}))
got = _read(me, key)
assert got["사본"]["따로"] is True and got["사본"]["갱신"] == []
assert got["문서"]["금액"][TOOL]["단가"] == "노무비 × 5%"
assert got["셈"]["계"] == was["셈"]["계"] and not got["사본"]["문서새판"]