Files
Aislo/resources/tester/test_826_1_layer_index.py
T
eomsangdonandClaude Opus 5.5 e203cbf6da fix(859-1 ㉰): M02 층 목록 기준금액 — 내 기계를 고치거나 지운 뒤 바로 새 값
- 까닭 = 목록 길이 지금 층을 안 정해(store.root() = 마스터) 셈이 그 층 내 기계를 못 찾고 SK 값 사본(저장 때 값)을 읽음
- 고침 = 요약 셈(_fresh)을 store.at(그 층) 안에서 — 내 기계 · 자동 따라옴 판정이 그 층 기준(열었을 때와 같음)
- 색인 자국은 이미 그 층 곁 파일(내기계 · 개인자재) · M01 폴더(기초 문서 포함)를 담음 — 따로 안 고침
- test_826_1 — 내 기계 200 → 600 → 지움: SK · 담은 SC 목록 금액 200 → 600 → 600(고침 없이 = 200 으로 실패 확인)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 22:03:30 +09:00

234 lines
8.8 KiB
Python

"""826-1 층 목록 요약 색인 — 답 = 다시 셈한 것 · 자국 같으면 항목 파일 안 엶 · 고침 · 지움 · 더함 ·
참조 고침 · M01 값 바뀜 · 색인 깨짐 뒤에도 맞음 · 판 충돌(409) 그대로."""
from __future__ import annotations
import json
import shutil
from pathlib import Path
import pytest
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Layer_Index as index
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
from resources.tester.test_m02_labor_ref import COMPANY, world # noqa: F401 — 같은 임시 층
PCT = "GC001109" # 원/㎡ · 인력 둘 + 덧줄 %
WAGE = "LB000001"
PCT_WAGE = "LB000002" # 보통인부 — PCT 바탕 줄
LIB = ("sangeun", "precombo", "labor")
@pytest.fixture()
def fresh(world, monkeypatch): # noqa: F811
"""색인 기억 비움 — 시험끼리 안 섞임."""
monkeypatch.setattr(index, "_MEM", {})
monkeypatch.setattr(library_uses, "_LOADED", [])
monkeypatch.setattr(library_uses, "_IDS", {})
return world
def _forget():
index._MEM.clear()
library_uses._LOADED.clear()
library_uses._IDS.clear()
def _sk(folder, name, extra=None):
doc = {"이름": name, "단위": "㎡", "바탕": {"로직": PCT}, "더한줄": extra or []}
with store.at(folder):
return refs.create("sangeun", doc)["이름"]
def _wage_line(qty=1):
return {"종류": "인력", "요소": WAGE, "이름": "보통인부", "단위": "인", "수량": qty}
def _old(folder):
rows = layers.list_templates(folder)
refs.summaries(folder, rows)
return rows
def _new(folder):
rows = index.list_rows(folder)
index.summaries(folder, rows)
return rows
def _same(folder):
got = _new(folder)
assert json.dumps(got, ensure_ascii=False) == json.dumps(_old(folder), ensure_ascii=False)
return got
@pytest.fixture()
def reads(monkeypatch):
"""항목 파일(서고 · 일위대가) 읽기 수."""
seen: list[str] = []
real = Path.read_bytes
def counting(self):
if self.parent.name in LIB:
seen.append(f"{self.parent.name}/{self.stem}")
return real(self)
monkeypatch.setattr(Path, "read_bytes", counting)
return seen
def _shelf(w):
up = _sk(w["company"], "회사 단가산출")
mine = w["personal"]
a = _sk(mine, "가", [_wage_line()])
b = _sk(mine, "나", [{"참조": {**COMPANY, "키": up}, "수량": 2}])
with store.at(mine):
sc = refs.create(
"precombo",
{
"이름": "일위대가",
"단위": "㎡",
"담은로직": [{"참조": {**COMPANY, "키": up}, "수량": {"손": 3}}],
},
)["이름"]
return up, a, b, sc
def test_same_and_no_reads_when_stamps_same(fresh, reads):
up, a, b, sc = _shelf(fresh)
mine = fresh["personal"]
first = _same(mine)
assert {r["이름"] for r in first} >= {a, b, sc} and first[0]["기준금액"] is not None
reads.clear()
assert _new(mine) == first and reads == [] # 메모리 기억
_forget()
reads.clear()
assert _new(mine) == first and reads == [] # 디스크 파생 저장본(서버 다시 뜸)
# 쓰는곳수 — 회사 SK 를 개인 SK 「나」 가 씀(사전조합은 사본으로 펼쳐 담음 · 740-1)
company = _same(fresh["company"])
assert company[0]["쓰는곳수"] == 1
def test_edit_delete_add_and_dep_change(fresh, reads):
up, a, b, sc = _shelf(fresh)
mine = fresh["personal"]
gone = _sk(mine, "지울것")
_same(mine)
with store.at(mine): # 고침 · 지움
got = store.read("sangeun", a)
store.write("sangeun", a, got["판"], {**got["문서"], "더한줄": [_wage_line(3)]})
store.delete("sangeun", gone)
c = _sk(mine, "다") # 더함
reads.clear()
rows = _new(mine)
assert set(reads) == {f"sangeun/{a}", f"sangeun/{c}"} # 바뀐 항목만 다시 읽음
assert rows == _old(mine)
titles = {r["이름"]: r.get("제목") for r in rows if r["종류"] in index.layers.LIBRARY_KINDS}
assert gone != c and titles == {
a: "가",
b: "나",
c: "다",
sc: "일위대가",
} # 지운 키는 빠지고 새 것은 새 번호(854-1 · 지운 번호 안 다시 씀)
reads.clear()
was = {r["이름"]: r.get("기준금액") for r in _new(mine)}
assert reads == []
with store.at(fresh["company"]): # 사전조합이 담은 위 층 SK 고침 → 그 사전조합만 다시
got = store.read("sangeun", up)
store.write("sangeun", up, got["판"], {**got["문서"], "더한줄": [_wage_line(5)]})
reads.clear()
now = {r["이름"]: r.get("기준금액") for r in _new(mine)}
assert set(reads) == {f"precombo/{sc}", f"sangeun/{up}"}
assert now[sc] != was[sc] and {k: v for k, v in now.items() if k != sc} == {
k: v for k, v in was.items() if k != sc
}
assert _new(mine) == _old(mine)
def test_m01_change_recounts_amount(fresh, tmp_path, monkeypatch):
copy = tmp_path / "m01"
copy.mkdir()
for path in Path(m01.FOLDER).glob("*.json"):
shutil.copyfile(path, copy / path.name)
shutil.copytree(Path(m01.FOLDER) / "기계", copy / "기계") # 기계 = 폴더(826-2)
monkeypatch.setattr(m01, "FOLDER", copy)
mine = fresh["personal"]
a = _sk(mine, "가") # 수식 사본 있는 SK — 개인 층 = M01 자동 따라옴(836-2)
one = next(r for r in _same(mine) if r["이름"] == a)["기준금액"]
assert one is not None
wages = json.loads((copy / "인력.json").read_text(encoding="utf-8"))
for row in wages["줄"]:
if row.get("키") == PCT_WAGE:
row["값"] = float(row["값"]) * 2
(copy / "인력.json").write_text(json.dumps(wages, ensure_ascii=False), encoding="utf-8")
two = next(r for r in _same(mine) if r["이름"] == a)["기준금액"]
assert two != one
def test_my_machine_change_recounts_amount(fresh):
"""내 기계를 고치면 목록 기준금액(SK · 담은 SC)이 바로 새 값 · 지워도 그대로(요구 902) —
목록 셈의 지금 층 = 그 층(서버 길은 층을 안 정함)."""
from M02_MasterTemplete import M02_MyMachine as mym
mine = fresh["personal"]
with store.at(mine):
made = mym.create({"이름": "sub3임시", "규격": "1", "방식": "직접",
"시간당": {"노무비": 0, "재료비": 0, "경비": 200}}) # fmt: skip
key = made["줄"]["키"]
body = {"이름": "기", "단위": "시간", "바탕": {"로직": "GC001199"},
"입력값": {"기계": made["줄"]["원문번호"]}, "더한줄": []} # fmt: skip
sk = refs.create("sangeun", body)["이름"]
layer, owner = refs.where(mine)
ref = {"참조": {"층": layer, "주인": owner, "키": sk}, "수량": {"손": 1}}
sc = refs.create("precombo", {"이름": "조", "단위": "시간", "담은로직": [ref]})["이름"]
def amounts():
rows = _new(mine)
return [next(r for r in rows if r["이름"] == k)["기준금액"] for k in (sk, sc)]
assert amounts() == [200, 200]
with store.at(mine):
mym.update(key, {**made["줄"], "시간당": {"노무비": 0, "재료비": 0, "경비": 600}})
assert amounts() == [600, 600]
with store.at(mine):
mym.delete(key)
assert amounts() == [600, 600]
def test_broken_index_rebuilds(fresh):
_up, _a, _b, _sc = _shelf(fresh)
mine = fresh["personal"]
first = _same(mine)
folder = index.derived_dir(layers.storage_root(), index.KIND)
for path in folder.glob("*.json"):
path.write_text("{깨짐", encoding="utf-8")
_forget()
assert _same(mine) == first
for path in folder.glob("*.json"):
path.write_text(json.dumps({"key": path.stem, "value": {"sangeun/x": 1}}), encoding="utf-8")
_forget()
assert _same(mine) == first
shutil.rmtree(folder)
_forget()
assert _same(mine) == first
def test_version_conflict_still_409(fresh):
mine = fresh["personal"]
a = _sk(mine, "가")
listed = next(r for r in index.list_rows(mine) if r["이름"] == a)["판"]
path = layers.template_path(mine, "sangeun", a)
assert listed == layers.version_of(path)
doc = json.loads(path.read_bytes())
layers.write_template(
mine, "sangeun", a, {**doc, "단위": "m"}, version=listed, check_version=True
)
with pytest.raises(layers.StaleTemplate): # 옛 판으로 또 저장
layers.write_template(mine, "sangeun", a, doc, version=listed, check_version=True)
fresh_ver = next(r for r in index.list_rows(mine) if r["이름"] == a)["판"]
assert fresh_ver == layers.version_of(path) != listed