# 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["사본"]["문서새판"]