Files
Aislo/resources/tester/test_826_2_machine_files.py
T
eomsangdonandClaude Opus 5.5 7e6190f8d3 refactor(855-E L3ⓐ): M01 기초 저장 · 검사 · 막힘 세기 = 수식 문서 기준 · 로직 줄 쓰기 = Store_Logic.mirror 한 자리
앞 세션 auto 커밋 cce57c298(Store_Logic 새 길 · /logic 답 머리만 · 판 = 문서 파일 지문 · 개정 = 문서 머리 대조 · 별칭 · 기계 등록 · [신규] · [삭제])에 이어
- Store_Cache: 막힘 세기(blocks · counted)를 문서 파일마다 · 저장 검사 logic_errors = 키 겹침 · 대장(요소 + 문서 키) · 연결 · 문서 막힘(check_logics 로직 줄 검사 걷음) · _docs_of = 문서 전부 · narrow 로직 갈래 걷음 · check_saved(부름 0) 지움
- Store_Save: 기초(로직 파일) 받지 않음(400) · gone · labor_errors(whole) 갈래 걷음
- Store_Logic: 정본 파일에도 새 기초(그 파일 표 키 — 옛 /save 와 같음) · 지움 검사에 조합 · 지운 기초를 부르던 문서 더함(옛 422 그대로) · 쓰는 곳 409 는 Doc.remove 로(옛 자리)
- 시험(옛 /save 로 로직 줄 셈 칸 고침 · /logic 답 셈 칸을 붙든 것 = 죽은 길): 새 test_855_l3_doc_only(로직 파일 없음 + 같이 쓰기 끔 = 켬과 답 같음 · 목록 · 상세 · 저장 · 개정 409 · 판 409 · 별칭 · 신규 · 복사 · 삭제 · 기계 등록)
  · test_m01_cache 셈 칸 /save 검사 셋 · test_794_1 식 고침 /save 422 걷음(셈 칸 고침 = 문서 저장 몫 · /save 는 머리만 씀)
  · test_m01_make 「시험 계산에 돈다」 → 빈 문서로 열림 · test_m01_api · test_m01_text 옛 셈 길 시험은 로직 줄 사본에서 읽음
  · test_854_2_m01_key_book 대장 끊김 = 인력 줄 + 기초 문서 쓰기 · test_794_1b · test_804_7 판 = 문서 파일 · test_802_3 문서 없는 키 = 404(빈 문서 안 지음)
  · test_826_2 좁힌 검사 = 판정만 견줌(기초 흠 글이 문서 꼴) · 로직 갈래 셋 뺌 · test_m01_copy 옛 시트 길 걷고 master_copy 왕복만 · test_854_2_m01_copy_doc 식 복사 → 기본정보 고친 복사
  · test_713_1 · test_796_1 row_print 줄 뺌(row_print 지움)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 08:37:53 +09:00

221 lines
11 KiB
Python

"""826-2 기계 = 항목 하나 파일 하나(M01 기계 · 내 기계) + M01 저장 길 줄이기 — 지킴 시험(임시 사본만).
① 폴더 → 옛 한 파일 꼴(머리 · 줄 · 키 차례) · 옮기는 빌더 왕복 같음 · 두 번 써도 안 바뀜
② 한 대 고침 = 파일 하나만 · 새 기계 = 파일 하나 더함(끝) · 지움 = 파일 하나 지움 · 판 충돌 409
③ 내 기계 — 옛 `내기계.json` 은 읽을 때 폴더로 한 번 옮김(내용 · 다음 번호 같음 · 옛 파일 지움)
④ 저장 검사 좁히기 — 옛 길(폴더 두 번 읽고 전체 검사 두 번)과 같은 판정(걸림 · 안 걸림 · 견본 고침 열일곱)
기본 = 갈래(기계 · 자재 · 인력 · 유가 · 표 · 조합)마다 하나 이상 일곱(`SAMPLE`) · 전수 = `AISLO_TEST_ALL=1`
(855 L3 ⓐ — 기초 연결 흠 글은 수식 문서 기준이라 옛 로직 줄 글과 꼴이 다름 → 판정만 견줌 · 기초(로직 파일) 저장은
`Store_Logic` 길이라 로직 갈래 셋은 `test_m01_make` · `test_855_l3_doc_only` 가 봄)
"""
from __future__ import annotations
import copy
import json
import shutil
import sys
from pathlib import Path
import pytest
from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Store_Cache as cache
from M02_MasterTemplete import M02_MyMachine as mym
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / "resources" / "master_data" / "scripts"))
import master_machine_files as mmf # noqa: E402
from helper_test_all import ALL # noqa: E402
#: ④ 기본 표본 — 갈래마다 하나 이상 · 오류 남 · 안 남 둘 다
SAMPLE = {
"기계 값",
"기계 지움(로직이 씀)",
"자재 지움(로직이 씀)",
"인력 준용 끊김",
"유가 값",
"표 조건 틀림",
"조합 지움",
}
REAL = store.FOLDER
cm, mk = store.cm, store.mk
M, MT, LB, MO = mmf.NAME, "재료_자재품목.json", "인력.json", "재료_유가전력.json"
@pytest.fixture
def master(tmp_path: Path, monkeypatch) -> Path:
for path in REAL.glob("*.json"):
if not path.name.startswith("_") or path.name == mk.BOOK.name:
shutil.copy(path, tmp_path / path.name)
shutil.copytree(REAL / mmf.DIR, tmp_path / mmf.DIR)
monkeypatch.setattr(store, "FOLDER", tmp_path)
return tmp_path
def _snap(folder: Path) -> dict[str, bytes]:
return {p.name: p.read_bytes() for p in (folder / mmf.DIR).glob("*.json")}
def _rows(file: str) -> list[dict]:
data = store.read(file)[0]
return data[store.items_key(data)]
def _row(file: str, key: str) -> dict:
return copy.deepcopy(next(r for r in _rows(file) if str(r["키"]) == key))
def _part(file: str, *changes: dict) -> dict:
return {"file": file, "version": store.read(file)[1], "changes": list(changes)}
# ① 폴더 = 옛 한 파일 꼴 ─────────────────────────────────────────────
def test_folder_reads_as_one_table(tmp_path: Path) -> None:
data, version = mmf.table(REAL)
assert list(data) == ["그룹", "원문", "구분", "줄"] and data["그룹"] == "기계"
keys = [r["키"] for r in data["줄"]]
assert len(keys) >= 655 and keys == sorted(keys) == [
p.stem for p in sorted((REAL / mmf.DIR).glob("EQ*.json"))
]
assert not (REAL / M).exists() # 같은 내용 두 벌 없음
assert cm.load([M])[M] == data and store.read(M) == (data, version)
assert cm.load()[M] == data # 마스터 전부 읽기에도 같은 이름으로
# 쓰고 다시 읽으면 같음 · 같은 것을 또 쓰면 바뀐 파일 0
mmf.write(tmp_path, data)
assert mmf.table(tmp_path) == (data, version) # 같은 글 → 같은 판
assert mmf.write(tmp_path, data) == []
# ② 고침 · 새 기계 · 지움 · 판 ─────────────────────────────────────────
def test_one_machine_one_file(master: Path) -> None:
first = _row(M, "EQ000001")
before = _snap(master)
first["값"]["가격"] += 1
got = store.save([_part(M, {"op": "edit", "key": "EQ000001", "row": first})])
after = _snap(master)
assert {n for n in after if after[n] != before.get(n)} == {"EQ000001.json"}
assert got == [{"file": M, "version": store.read(M)[1]}]
assert _row(M, "EQ000001") == first and store.loaded()[0][M]["줄"][0] == first
new = {**_row(M, "EQ000001"), "이름": "sub1임시기계", "원문번호": ""}
new.pop("키")
store.save([_part(M, {"op": "add", "row": new})])
added = set(_snap(master)) - set(after)
assert len(added) == 1 and _rows(M)[-1]["이름"] == "sub1임시기계" # 끝(다음 키)
key = _rows(M)[-1]["키"]
assert added == {f"{key}.json"} and store.loaded()[1].get(key)["이름"] == "sub1임시기계"
stale = _part(M, {"op": "delete", "key": key})
store.save([_part(M, {"op": "delete", "key": key})])
assert set(_snap(master)) == set(after) and key not in [r["키"] for r in _rows(M)]
with pytest.raises(store.StoreError) as e: # 지우기 전 판으로 또 저장
store.save([stale])
assert e.value.status == 409 and e.value.detail == {"stale": [M]}
# ③ 내 기계 옮김 ───────────────────────────────────────────────────────
def test_my_machine_moves_once(tmp_path: Path) -> None:
rows = [{"키": f"EQP42-{n:04d}", "이름": f"sub1임시{n}", "값": {"가격": n}} for n in (1, 2, 10)]
old = {"줄": rows, "다음": 11}
(tmp_path / mym.FILE).write_text(json.dumps(old, ensure_ascii=False), encoding="utf-8")
got = mym._read(tmp_path)
assert got == old and not (tmp_path / mym.FILE).exists() # 내용 · 차례 같음 · 옛 파일 지움
assert sorted(p.name for p in (tmp_path / mym.DIR).iterdir()) == [
"EQP42-0001.json", "EQP42-0002.json", "EQP42-0010.json", mym.NEXT,
] # fmt: skip
assert mym._read(tmp_path) == old and mym.rows(tmp_path) == rows
assert mym._read(tmp_path / "없음") == {"줄": [], "다음": 1}
(tmp_path / mym.FILE).write_text(json.dumps({"줄": [], "다음": 5}), encoding="utf-8")
assert mym._read(tmp_path)["다음"] == 11 # 옛 코드가 다시 쓴 옛 파일 — 번호 뒤로 안 감
# ④ 저장 검사 좁히기 = 옛 길과 같은 오류 ─────────────────────────────────
def _old_check(files: dict, changed: list[str], book: dict, narrowed) -> list[str]:
"""826-2 전 `Store_Cache.check_saved` 그대로 — 폴더 전부 색인 · 틀 · 조합 · 모든 층 문서."""
whole = cm.mf.Master(files)
out = [x for name in changed for x in cm.check_form(name, files[name])]
out += cm.check_logics(files, whole, book, narrowed and narrowed[:2])
if narrowed and narrowed[2]:
out += cm.check_links(whole)
return out + cm.mcb.check_all(files, whole) + cache.labor_errors(whole)
def _old(batch: list[dict]) -> list[str]:
"""826-2 전 저장 검사 길 — 폴더 통째 두 번 읽음 · 전 · 후 전체 검사(쓰지 않음)."""
before, after = cm.load(folder=store.FOLDER), cm.load(folder=store.FOLDER)
path = store.FOLDER / mk.BOOK.name
book = mk.load_book(path)
for part in batch:
store._apply(after[part["file"]], copy.deepcopy(part["changes"]), part["file"], book)
mk.finish(book)
names = [part["file"] for part in batch]
narrowed = cache.narrow(store.FOLDER, batch, before, after)
old = set(_old_check(before, names, mk.load_book(path), narrowed))
return [x for x in _old_check(after, names, book, narrowed) if x not in old]
def _new(batch: list[dict]) -> list[str]:
try:
store.save(copy.deepcopy(batch))
except store.StoreError as e:
assert e.status == 422, e.detail
return e.detail["errors"]
return []
def _edit(file: str, key: str, fix) -> list[dict]:
row = _row(file, key)
fix(row)
return [_part(file, {"op": "edit", "key": key, "row": row})]
def _delete(file: str, key: str) -> list[dict]:
return [_part(file, {"op": "delete", "key": key})]
def _add(file: str, like: str, **cols) -> list[dict]:
row = {**_row(file, like), "원문번호": "", **cols}
row.pop("키")
return [_part(file, {"op": "add", "row": row})]
def test_narrow_check_same_as_before(master: Path, tmp_path: Path, monkeypatch) -> None:
monkeypatch.setattr(cache, "_labor_files", lambda: []) # 층 일위대가 문서는 안 봄(임시 사본만)
used = next(r["키"] for r in _rows(M) if r.get("원문번호") == "0201-0100")
combo = [r["키"] for r in _rows(cm.mcb.FILE)]
table = next(n for n in store.loaded()[0] if n.startswith("계수_"))
cell = _rows(table)[0]["키"]
def bump(r):
r["값"]["가격"] += 1
cases = [ # (이름, 할 일, 오류가 나야 함)
("기계 값", lambda: _edit(M, "EQ000001", bump), False),
("기계 별칭", lambda: _edit(M, "EQ000002", lambda r: r.update(별칭="sub1임시")), False),
("기계 별칭 빈 글", lambda: _edit(M, "EQ000002", lambda r: r.update(별칭=" ")), True),
("기계 지움(로직이 씀)", lambda: _delete(M, used), True),
("기계 원문번호", lambda: _edit(M, used, lambda r: r.update(원문번호="9999-9999")), True),
("새 기계", lambda: _add(M, "EQ000003", 이름="sub1임시기계"), False),
("자재 값", lambda: _edit(MT, "MT003175", lambda r: r.update(비고="sub1")), False),
("자재 지움(로직이 씀)", lambda: _delete(MT, "MT003175"), True),
("기계 + 자재 이름(고르기 후보 0)", lambda: _edit(M, "EQ000004", bump) + _edit(MT, "MT000008", lambda r: r.update(이름="sub1임시자재")), True),
("인력 값", lambda: _edit(LB, "LB000003", lambda r: r.update(값=r["값"] + 1)), False),
("인력 지움(로직이 씀)", lambda: _delete(LB, "LB000002"), True),
("인력 준용 끊김", lambda: _edit(LB, "LB000006", lambda r: r.update(준용="LB999999")), True),
("유가 값", lambda: _edit(MO, "MO000001", lambda r: r.update(값=r["값"] + 1)), False),
("표 조건 틀림", lambda: _edit(table, cell, lambda r: r["조건"].update(sub1="모름")), True),
("조합 이름 겹침", lambda: _edit(cm.mcb.FILE, combo[0], lambda r: r.update(이름=_rows(cm.mcb.FILE)[1]["이름"])), True),
("조합 지움", lambda: _delete(cm.mcb.FILE, combo[-1]), False),
("새 자재", lambda: _add(MT, "MT000008", 이름="sub1임시새자재"), False),
] # fmt: skip
assert SAMPLE <= {name for name, _, _ in cases}
for name, make, bad in cases:
if not ALL and name not in SAMPLE:
continue
batch = make()
want = _old(batch)
got = _new(batch)
assert bool(got) == bool(want) == bad, (name, got[:3], want[:3])