Merge remote-tracking branches 'origin/main_laptop_1', 'origin/sub_laptop_5' and 'origin/sub_laptop_6' into sub_laptop_4
This commit is contained in:
@@ -81,6 +81,23 @@ def new_answer(links, doc: dict, given: dict | None = None):
|
||||
return {"결과": got["결과"]} if doc.get("결과") else {k: got.get(k) for k in KEYS}
|
||||
|
||||
|
||||
def cases_of(whole, row: dict) -> list[tuple]:
|
||||
"""(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력) — 기본 + 고르기 입력의 다른 갈래 하나씩."""
|
||||
base = meq.given_of(whole, row)
|
||||
cases = [("", base, None)]
|
||||
for spec in row.get("입력") or []:
|
||||
for opt in spec.get("고르기") or []:
|
||||
if str(opt) != str(base.get(spec["이름"])):
|
||||
one = {spec["이름"]: opt}
|
||||
cases.append((f"{spec['이름']}={opt}", {**base, **one}, one))
|
||||
return cases
|
||||
|
||||
|
||||
def agree(old, new) -> bool:
|
||||
"""대조 같음 — 같은 값 · 둘 다 못 셈."""
|
||||
return old == new or (isinstance(old, str) and isinstance(new, str))
|
||||
|
||||
|
||||
def _text(v) -> str:
|
||||
if isinstance(v, str):
|
||||
return v
|
||||
@@ -137,17 +154,11 @@ def build(log=print) -> dict:
|
||||
links = ml.Links(whole, docs)
|
||||
runs, both_out = [], 0
|
||||
for _, row in items:
|
||||
key, base = str(row["키"]), meq.given_of(whole, row)
|
||||
cases = [("", base, None)] # (옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력)
|
||||
for spec in row.get("입력") or []:
|
||||
for opt in spec.get("고르기") or []:
|
||||
if str(opt) != str(base.get(spec["이름"])):
|
||||
one = {spec["이름"]: opt}
|
||||
cases.append((f"{spec['이름']}={opt}", {**base, **one}, one))
|
||||
for label, given, changed in cases:
|
||||
key = str(row["키"])
|
||||
for label, given, changed in cases_of(whole, row):
|
||||
old = old_answer(whole, row, given)
|
||||
new = new_answer(links, docs[key], changed)
|
||||
same = old == new or (isinstance(old, str) and isinstance(new, str))
|
||||
same = agree(old, new)
|
||||
both_out += isinstance(old, str) and isinstance(new, str)
|
||||
runs.append(
|
||||
{
|
||||
|
||||
@@ -14,6 +14,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
@@ -24,7 +25,9 @@ import master_machine_crew as mcrew
|
||||
import master_material as mm
|
||||
import master_pick as mp
|
||||
|
||||
FOLDER = Path(__file__).resolve().parents[1] / "수식문서"
|
||||
# 화면 저장 시험 사본(`AISLO_MASTER_DIR` — `M01_MasterData_Store.FOLDER` 와 같이) · 없으면 정본
|
||||
_HOME = os.environ.get("AISLO_MASTER_DIR") or Path(__file__).resolve().parents[1]
|
||||
FOLDER = Path(_HOME).resolve() / "수식문서"
|
||||
_ARITH_OK = ("num", "bin", "neg")
|
||||
|
||||
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
@@ -77,7 +78,9 @@ def save_book(book: dict, path: Path = BOOK) -> None:
|
||||
comma = "," if i < len(items) - 1 else ""
|
||||
lines.append(f" {json.dumps(key)}: {json.dumps(v, ensure_ascii=False)}{comma}")
|
||||
lines += [" }", "}"]
|
||||
path.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n")
|
||||
tmp = path.with_name(f".{path.name}.tmp") # 임시 파일 → 교체(원자적 · 끊겨도 반쪽 대장 없음)
|
||||
tmp.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n")
|
||||
os.replace(tmp, path)
|
||||
|
||||
|
||||
def lookup(book: dict) -> dict:
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,164 @@
|
||||
"""855-A 지킴 도우미 — 로직마다 셈 경우(기본 + 옵션 표본) · 옛 엔진 대 새 계산기 층 가름 · 새 답 지문.
|
||||
|
||||
- 경우 = 빌더 대조와 같은 표본(`build_수식문서_802_2.build`) — 기본 입력(수식 탭 기본값) + 고르기 입력의
|
||||
다른 갈래 하나씩(나머지 기본).
|
||||
- 옛 = `master_formula.run` → `master_cut.engine` · 새 = 저장된 수식 문서(`master_doc_link.load_all`) ·
|
||||
`master_doc_calc.calc`.
|
||||
- 층(앞 층이 다르면 뒤 층 안 봄): L0 합계 · L1 줄 이름별 비목 금액 · L2 줄 꼴(차례 · 이름 · 금액 · 비목) ·
|
||||
L3 수량 · 단가. 「보임」 = 금액은 같고 보이는 단가만 다름(옛 = 줄 끝수 자리로 자른 단가 · 새 = 날 값 /
|
||||
수량 0 줄 단가 0 ↔ 빈 값 / 값 없는 줄 단가 빈 값 ↔ 채움 / 묶음 단가 = 계로 맞댐).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import importlib
|
||||
import json
|
||||
from collections import defaultdict
|
||||
from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal
|
||||
from functools import lru_cache
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
|
||||
|
||||
mf = importlib.import_module("master_formula")
|
||||
mcut = importlib.import_module("master_cut")
|
||||
mc = importlib.import_module("master_doc_calc")
|
||||
ml = importlib.import_module("master_doc_link")
|
||||
meq = importlib.import_module("master_equation")
|
||||
build = importlib.import_module("build_수식문서_802_2")
|
||||
|
||||
KEYS = ("노무비", "재료비", "경비", "계")
|
||||
SEEN = "보임"
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def world():
|
||||
"""(로직 줄 목록, M01 색인, 수식 문서 {키: 문서}, 연결)."""
|
||||
files, whole = m01.loaded()
|
||||
docs = ml.load_all()
|
||||
rows = [r for d in files.values() if d.get("그룹") == "로직" for r in d.get("줄") or []]
|
||||
return rows, whole, docs, ml.Links(whole, docs)
|
||||
|
||||
|
||||
def cases(row: dict, options: bool) -> list[tuple[str, dict, dict | None]]:
|
||||
"""(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력)."""
|
||||
whole = world()[1]
|
||||
base = meq.given_of(whole, row)
|
||||
out = [("", base, None)]
|
||||
if options:
|
||||
for spec in row.get("입력") or []:
|
||||
for opt in spec.get("고르기") or []:
|
||||
if str(opt) != str(base.get(spec["이름"])):
|
||||
one = {spec["이름"]: opt}
|
||||
out.append((f"{spec['이름']}={opt}", {**base, **one}, one))
|
||||
return out
|
||||
|
||||
|
||||
def old_run(row: dict, given: dict):
|
||||
whole = world()[1]
|
||||
try:
|
||||
return mcut.engine(whole, row["키"], mf.run(whole, row["키"], mf.fill_empty(row, given)))
|
||||
except Exception: # 옛 엔진 멈춤도 대조 값
|
||||
return None
|
||||
|
||||
|
||||
def new_run(doc: dict, changed: dict | None):
|
||||
try:
|
||||
got = mc.calc(doc, world()[3], changed)
|
||||
except Exception:
|
||||
return None
|
||||
return got if got.get("셈됨") else None
|
||||
|
||||
|
||||
def _d(v):
|
||||
try:
|
||||
return Decimal(str(v))
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def _unit(v):
|
||||
return _d(v.get("계")) if isinstance(v, dict) else _d(v)
|
||||
|
||||
|
||||
def _per_name(lines) -> dict:
|
||||
acc: dict = defaultdict(lambda: defaultdict(Decimal))
|
||||
for ln in lines or []:
|
||||
for k, v in (ln.get("비목") or {}).items():
|
||||
if _d(v) is not None:
|
||||
acc[str(ln.get("이름"))][k] += _d(v)
|
||||
return {n: {k: v for k, v in b.items() if v} for n, b in acc.items()}
|
||||
|
||||
|
||||
def _shape(lines) -> list:
|
||||
return [
|
||||
(
|
||||
str(ln.get("이름")),
|
||||
_d(ln.get("금액")),
|
||||
tuple(sorted((k, _d(v)) for k, v in (ln.get("비목") or {}).items() if v is not None)),
|
||||
)
|
||||
for ln in lines or []
|
||||
]
|
||||
|
||||
|
||||
def _cut_only(a, b) -> bool:
|
||||
"""옛 단가 = 새 날 값을 옛 자리로 자른 값(버림 · 반올림 · 올림 어느 하나)."""
|
||||
ua, ub = _unit(a.get("단가")), _unit(b.get("단가"))
|
||||
if ua is None and _d(a.get("금액")) is None and _d(b.get("금액")) is None:
|
||||
return True # 값 없는 줄 — 금액 둘 다 빈 값
|
||||
if ub is None and ua == 0 and _d(a.get("수량")) == 0:
|
||||
return True # 수량 0 줄 — 금액 0
|
||||
if ua is None or ub is None:
|
||||
return False
|
||||
return ua in (ub.quantize(ua, m) for m in (ROUND_DOWN, ROUND_HALF_UP, ROUND_UP))
|
||||
|
||||
|
||||
def level(old, new, money: bool) -> str | None:
|
||||
"""다름 층 — None = 같음(둘 다 못 셈 포함) · 「보임」 = 보이는 단가만 다름."""
|
||||
if old is None or new is None:
|
||||
return None if old is None and new is None else "L0"
|
||||
keys = KEYS if money else ("결과",)
|
||||
if any(_d(old.get(k)) != _d(new.get(k)) for k in keys):
|
||||
return "L0"
|
||||
if not money:
|
||||
return None
|
||||
if _per_name(old["줄"]) != _per_name(new["줄"]):
|
||||
return "L1"
|
||||
if _shape(old["줄"]) != _shape(new["줄"]):
|
||||
return "L2"
|
||||
seen = False
|
||||
for a, b in zip(old["줄"], new["줄"]):
|
||||
if _d(a.get("수량")) != _d(b.get("수량")):
|
||||
return "L3"
|
||||
if _unit(a.get("단가")) != _unit(b.get("단가")):
|
||||
if not _cut_only(a, b):
|
||||
return "L3"
|
||||
seen = True
|
||||
return SEEN if seen else None
|
||||
|
||||
|
||||
def adopted(key: str, label: str, lv: str) -> bool:
|
||||
"""채택된 차이(요구 714-3 · 빌더 `ADOPTED`) — 합계는 그 목록만 · 줄 비목은 같은 까닭
|
||||
(식 속 단가산출 부름 = 끝수 뒤 값)이 있는 문서만."""
|
||||
if lv == "L0":
|
||||
return (key, label) in build.ADOPTED
|
||||
return lv == "L1" and build._uses_raw_sub(world()[2][key])
|
||||
|
||||
|
||||
def answer(got) -> object:
|
||||
"""새 답의 지문 꼴 — 노 · 재 · 경 · 계(돈 아닌 = 결과) · 줄(이름 · 금액 · 비목)."""
|
||||
if got is None:
|
||||
return "못 셈"
|
||||
if "결과" in got and got.get("계") is None:
|
||||
return {"결과": str(got.get("결과"))}
|
||||
return {
|
||||
"합": [str(got.get(k)) for k in KEYS],
|
||||
"줄": [[n, str(m), [[k, str(v)] for k, v in b]] for n, m, b in _shape(got.get("줄"))],
|
||||
}
|
||||
|
||||
|
||||
def fingerprint(key: str, row: dict, options: bool = True) -> str:
|
||||
doc = world()[2][key]
|
||||
got = [[label, answer(new_run(doc, changed))] for label, _, changed in cases(row, options)]
|
||||
raw = json.dumps(got, ensure_ascii=False, sort_keys=True)
|
||||
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
|
||||
@@ -9,6 +9,7 @@ from pathlib import Path
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path[:0] = [str(ROOT), str(ROOT / "resources/master_data/scripts")]
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as doc # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Equation as eq # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Store as store # noqa: E402
|
||||
|
||||
@@ -117,10 +118,10 @@ def test_drop_guard_and_unused_input():
|
||||
|
||||
def test_candidates():
|
||||
whole = store.loaded()[1]
|
||||
got = eq.links({"갈래": "표", "검색": "합판거푸집 폼타이", "분류": ""})
|
||||
got = doc.candidates({"갈래": "표", "검색": "합판거푸집 폼타이", "분류": ""})
|
||||
assert got["후보"] and "조건" in got["후보"][0]
|
||||
assert eq.links({"갈래": "요소", "검색": "형틀목공", "분류": "인력"})["후보"]
|
||||
assert eq.links({"갈래": "로직", "검색": "합판거푸집", "분류": ""})["후보"]
|
||||
assert doc.candidates({"갈래": "요소", "검색": "형틀목공", "분류": "인력"})["후보"]
|
||||
assert doc.candidates({"갈래": "로직", "검색": "합판거푸집", "분류": ""})["후보"]
|
||||
assert whole is not None
|
||||
|
||||
|
||||
|
||||
@@ -379,14 +379,19 @@ def sweep(tag: str) -> dict:
|
||||
path = practice.FILES[tag]
|
||||
saved = fn.pack(excel(tag), path.name)
|
||||
out = {"블록": 0, "같음": 0, "다름": set(), "변수줄": 0, "자원줄": 0, "자원추정": 0}
|
||||
out["옛 검산 다름"] = set()
|
||||
for ln in (x for b in saved["산근"] for x in b["줄"]):
|
||||
out["변수줄"] += bool(ln.get("변수"))
|
||||
out["자원줄"] += bool(ln.get("자원"))
|
||||
for no, blk in fn.numbers(saved).items():
|
||||
out["블록"] += 1
|
||||
emitted = fn.emit(saved, no)
|
||||
_, _, got = nd.doc_and_money(emitted)
|
||||
sk, _, got = nd.doc_and_money(emitted)
|
||||
mine = {c: got.get(k) for c, k in nd.COST}
|
||||
old = nd.imp._money(nd.imp._run(sk, nd.whole())) or {} # 855-A 옛 검산(옛 엔진)
|
||||
pair = [(old.get(k), got.get(k)) for _, k in nd.COST]
|
||||
if any(a is None or b is None or nd.D(str(a)) != nd.D(str(b)) for a, b in pair):
|
||||
out["옛 검산 다름"].add((tag, no))
|
||||
nag = (emitted["원본"].get("계약") or {}).get("낙찰률")
|
||||
if nag:
|
||||
for c in "LMS":
|
||||
@@ -408,3 +413,4 @@ MONEY_SAMPLE = ("거창", "봉화")
|
||||
def test_money_equals_excel(tag: str) -> None:
|
||||
got = sweep(tag)
|
||||
assert got["블록"] and got["다름"] == {x for x in ODD_MONEY if x[0] == tag}, sorted(got["다름"])
|
||||
assert got["옛 검산 다름"] == set(), sorted(got["옛 검산 다름"]) # 855-A 옛 검산 = 새 셈
|
||||
|
||||
@@ -95,10 +95,6 @@ def test_기계_부품():
|
||||
assert {"GC001147", "GF000088"} <= tpl and len(tpl) == 15
|
||||
coef = m01_router.get_parts("계수식")["계수식"]
|
||||
assert {x["키"] for x in coef} == {"GC001143", "GC001191", "GC001192", "GC001193"}
|
||||
one = parts.of_machine("0201-0070")
|
||||
assert one["기계"] == {"이름": "굴착기(무한궤도)", "규격": "0.7㎥", "상세구분": "굴착기"}
|
||||
by = {t["키"]: t for t in one["틀"]}
|
||||
assert by["GC001147"]["규격"] == "버킷용량" and by["GF000088"]["문서"]["결과"] == "Q"
|
||||
|
||||
|
||||
def test_변환기가_표지를_옮김():
|
||||
|
||||
@@ -201,7 +201,7 @@ def test_company_and_other_refused(world):
|
||||
_at(world["company"], path.preview, sk, {"문서": doc})
|
||||
assert e.value.status == 404
|
||||
with pytest.raises(HTTPException) as e:
|
||||
route.my_machine_draft("personal", route.MachineBody(줄=_body()), "7/43", USER)
|
||||
route.my_machine_create("personal", route.MachineBody(줄=_body()), "7/43", USER)
|
||||
assert e.value.status_code == 403
|
||||
with pytest.raises(HTTPException) as e:
|
||||
doc_route.save_doc("personal", sk, doc_route.DocBody(문서=doc, 판=""), "7/43", USER)
|
||||
|
||||
@@ -0,0 +1,108 @@
|
||||
"""M01 [로직 복사/생성] 이 수식 문서도 같이 지음(PLAN 854-2 · 요구 896) — 사본 폴더에서만.
|
||||
|
||||
- 만들면 문서 있음 · 새 계산기 금액 = 옛 엔진 = 본뜬 로직 · 빌더가 다시 지어도 같은 글.
|
||||
- 지우면(`/logic/remove` · `/save` 지움) 문서도 없음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
import shutil
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from fastapi import FastAPI
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
from M01_MasterData import M01_MasterData_Router as router_module
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
from M01_MasterData import M01_MasterData_Store_Make as make
|
||||
|
||||
REAL = store.FOLDER
|
||||
SAMPLE = "GF000219" # 산림 13-4-1 메쌓기(인력)
|
||||
COSTS = ("노무비", "재료비", "경비", "계")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client(tmp_path: Path, monkeypatch) -> TestClient:
|
||||
for path in REAL.glob("*.json"):
|
||||
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
|
||||
shutil.copy(path, tmp_path / path.name)
|
||||
shutil.copytree(REAL / "기계", tmp_path / "기계")
|
||||
shutil.copytree(REAL / "수식문서", tmp_path / "수식문서")
|
||||
monkeypatch.setattr(store, "FOLDER", tmp_path)
|
||||
monkeypatch.setattr(doc_screen.ml, "FOLDER", tmp_path / "수식문서")
|
||||
doc_screen._memo.clear()
|
||||
app = FastAPI()
|
||||
app.include_router(router_module.router)
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _get(client: TestClient, url: str, **params) -> dict:
|
||||
res = client.get(url, params=params)
|
||||
assert res.status_code == 200, res.text
|
||||
return res.json()
|
||||
|
||||
|
||||
def _post(client: TestClient, url: str, body: dict) -> dict:
|
||||
res = client.post(url, json=body)
|
||||
assert res.status_code == 200, res.text
|
||||
return res.json()
|
||||
|
||||
|
||||
def _money(answer: dict) -> dict:
|
||||
return {k: Decimal(str(answer[k])) for k in COSTS}
|
||||
|
||||
|
||||
def _old(key: str) -> dict:
|
||||
"""옛 엔진 금액(빌더 대조와 같은 길 · 기본 입력)."""
|
||||
builder = importlib.import_module("build_수식문서_802_2")
|
||||
whole = store.loaded()[1]
|
||||
row = store.logic(key)["logic"]
|
||||
return _money(builder.old_answer(whole, row, builder.cases_of(whole, row)[0][1]))
|
||||
|
||||
|
||||
def test_복사로_만든_로직은_수식_문서가_있고_금액이_옛_엔진과_같다(client: TestClient) -> None:
|
||||
made = _post(client, "/api/m01/logic/copy", {"key": SAMPLE, "이름": "sub5임시 본뜸"})
|
||||
key = made["key"]
|
||||
assert key.startswith("GX") and made["수식문서"] is True
|
||||
got = _get(client, "/api/m01/logic/doc", key=key)
|
||||
assert got["새"] is False and got["파일"] == "수식_자체.json" and got["문서"]["식"]
|
||||
assert got["셈"]["셈됨"] is True
|
||||
source = _get(client, "/api/m01/logic/doc", key=SAMPLE)
|
||||
assert _money(got["셈"]) == _old(key) == _money(source["셈"]) and _old(key)["계"] > 0
|
||||
|
||||
# 빌더가 다음에 다시 지어도 같은 파일 글(옛 로직 줄이 있는 키 = 빌더 몫)
|
||||
builder = importlib.import_module("build_수식문서_802_2")
|
||||
result = builder.build(log=lambda *_: None)
|
||||
assert key in result["저장"]
|
||||
want = builder.files_of(result)["수식_자체.json"]
|
||||
assert (doc_screen.folder() / "수식_자체.json").read_text(encoding="utf-8") == want
|
||||
|
||||
# 지우면 문서도 같이
|
||||
info = _get(client, "/api/m01/logic", key=key)
|
||||
_post(
|
||||
client,
|
||||
"/api/m01/logic/remove",
|
||||
{"key": key, "file": info["file"], "version": info["version"]},
|
||||
)
|
||||
assert _get(client, "/api/m01/logic/doc", key=SAMPLE)["새"] is False
|
||||
assert key not in doc_screen.docs()
|
||||
|
||||
|
||||
def test_식_복사로_만든_로직도_문서가_있고_save_지움이면_문서도_없다(client: TestClient) -> None:
|
||||
view = _get(client, "/api/m01/logic/formula", key=SAMPLE)
|
||||
made = _post(
|
||||
client,
|
||||
"/api/m01/logic/formula/save",
|
||||
{"로직": view["로직"], "별칭": view["별칭"], "본뜬키": SAMPLE, "이름": "sub5임시 식복사"},
|
||||
)
|
||||
key = made["key"]
|
||||
assert made["수식문서"] is True and key in doc_screen.docs()
|
||||
assert _money(_get(client, "/api/m01/logic/doc", key=key)["셈"]) == _old(key)
|
||||
|
||||
body = {"file": make.OWN, "version": made["version"], "changes": [{"op": "delete", "key": key}]}
|
||||
_post(client, "/api/m01/save", {"files": [body]})
|
||||
assert key not in doc_screen.docs()
|
||||
@@ -0,0 +1,141 @@
|
||||
"""M01 수식 문서 쓰기 안전(PLAN 854-2 · 요구 894 걸음 1) — 잠금 · 판 대조(409) · 임시 파일 → 교체.
|
||||
|
||||
마스터 · 수식 문서 사본 폴더에서만 씀.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
|
||||
REAL = store.FOLDER
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def master(tmp_path: Path, monkeypatch) -> Path:
|
||||
for path in REAL.glob("*.json"):
|
||||
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
|
||||
shutil.copy(path, tmp_path / path.name)
|
||||
shutil.copytree(REAL / "기계", tmp_path / "기계")
|
||||
monkeypatch.setattr(store, "FOLDER", tmp_path)
|
||||
return tmp_path
|
||||
|
||||
|
||||
DOC_KEY = "GF000219" # 산림 13-4-1 메쌓기(인력)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def docs(master: Path, monkeypatch) -> Path:
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
|
||||
folder = master / "수식문서"
|
||||
shutil.copytree(REAL / "수식문서", folder)
|
||||
monkeypatch.setattr(doc_screen.ml, "FOLDER", folder)
|
||||
doc_screen._memo.clear()
|
||||
return folder
|
||||
|
||||
|
||||
def _client():
|
||||
from fastapi import FastAPI
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from M01_MasterData import M01_MasterData_Router as router_module
|
||||
|
||||
app = FastAPI()
|
||||
app.include_router(router_module.router)
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _renamed(doc: dict, tail: str) -> dict:
|
||||
return {**doc, "이름": f"{doc['이름']} {tail}"}
|
||||
|
||||
|
||||
def test_옛_판으로_저장하면_409_이고_앞_저장을_덮지_않는다(docs: Path) -> None:
|
||||
client = _client()
|
||||
got = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json()
|
||||
assert got["판"] and not got["새"]
|
||||
first = client.post(
|
||||
"/api/m01/logic/doc/save",
|
||||
json={"문서": _renamed(got["문서"], "sub5임시A"), "판": got["판"]},
|
||||
)
|
||||
assert first.status_code == 200, first.text
|
||||
again = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json()
|
||||
assert again["판"] == first.json()["판"] != got["판"] # 저장 뒤 판 = 다시 읽은 판
|
||||
late = client.post(
|
||||
"/api/m01/logic/doc/save",
|
||||
json={"문서": _renamed(got["문서"], "sub5임시B"), "판": got["판"]},
|
||||
)
|
||||
assert late.status_code == 409 and "그 사이 파일이 바뀜" in late.json()["detail"]
|
||||
assert again["문서"]["이름"].endswith("sub5임시A")
|
||||
now = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json()
|
||||
assert now["문서"]["이름"].endswith("sub5임시A") # 늦은 저장이 소리 없이 덮지 않음
|
||||
assert not list(docs.glob(".*.tmp"))
|
||||
|
||||
|
||||
def test_동시에_두_저장이면_하나만_되고_하나는_409(docs: Path, monkeypatch) -> None:
|
||||
import threading
|
||||
import time
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
|
||||
got = _client().get("/api/m01/logic/doc", params={"key": DOC_KEY}).json() # 화면 꼴(수 = JSON)
|
||||
real = doc_screen.layered
|
||||
|
||||
def slow(doc, key): # 두 저장이 겹치게 — 판 확인 · 쓰기 사이를 넓힘
|
||||
time.sleep(0.3)
|
||||
return real(doc, key)
|
||||
|
||||
monkeypatch.setattr(doc_screen, "layered", slow)
|
||||
plain = got["문서"]
|
||||
out: list[str] = []
|
||||
|
||||
def one(tail: str) -> None:
|
||||
try:
|
||||
doc_screen.save(_renamed(plain, tail), got["판"])
|
||||
out.append("ok")
|
||||
except doc_screen.store.StoreError as e:
|
||||
out.append(str(e.status))
|
||||
|
||||
runs = [threading.Thread(target=one, args=(t,)) for t in ("sub5임시A", "sub5임시B")]
|
||||
for t in runs:
|
||||
t.start()
|
||||
for t in runs:
|
||||
t.join()
|
||||
assert sorted(out) == ["409", "ok"]
|
||||
|
||||
|
||||
def test_기계_목록_등록이_바꾼_문서를_옛_판_저장이_덮지_않는다(docs: Path) -> None:
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
from M01_MasterData import M01_MasterData_Machine as machine
|
||||
|
||||
key = next(
|
||||
k
|
||||
for k, d in doc_screen.docs().items()
|
||||
if any(
|
||||
v.get("이름") == "기계" and (v.get("연결") or {}).get("갈래") == "선택"
|
||||
for v in d.get("변수") or []
|
||||
)
|
||||
)
|
||||
got = _client().get("/api/m01/logic/doc", params={"key": key}).json()
|
||||
machine._register_docs({key: ["sub5임시EQ"]}, set())
|
||||
after = doc_screen.read(key)
|
||||
assert after["판"] != got["판"]
|
||||
plain = got["문서"]
|
||||
with pytest.raises(doc_screen.store.StoreError) as e:
|
||||
doc_screen.save(_renamed(plain, "sub5임시"), got["판"])
|
||||
assert e.value.status == 409
|
||||
picks = next(v for v in doc_screen.read(key)["문서"]["변수"] if v.get("이름") == "기계")
|
||||
assert "sub5임시EQ" in picks["연결"]["목록"]
|
||||
|
||||
|
||||
def test_마스터만_사본인_시험은_정본_수식_문서를_안_쓴다(master: Path) -> None:
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
|
||||
path = doc_screen.folder() / "수식_자체.json" # 정본 폴더(사본으로 안 바꿈)
|
||||
raw = path.read_bytes()
|
||||
doc_screen.put(path, {"그룹": "수식문서", "로직파일": "", "줄": []})
|
||||
assert path.read_bytes() == raw
|
||||
@@ -0,0 +1,113 @@
|
||||
"""M01 저장 안전(PLAN 854-2 · 요구 894 걸음 1) — 마스터 사본 폴더에서만 씀.
|
||||
|
||||
- 키 대장 · 파일 쓰기: 중간에 끊겨도 대장 · 파일이 저장 전 그대로(대장만 앞서가지 않음).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
from M01_MasterData import M01_MasterData_Store_Save as save_mod
|
||||
|
||||
REAL = store.FOLDER
|
||||
OWN = "로직_자체.json"
|
||||
MACHINE = "EQ000002"
|
||||
LABOR = "LB000002" # 보통인부
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def master(tmp_path: Path, monkeypatch) -> Path:
|
||||
for path in REAL.glob("*.json"):
|
||||
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
|
||||
shutil.copy(path, tmp_path / path.name)
|
||||
shutil.copytree(REAL / "기계", tmp_path / "기계")
|
||||
monkeypatch.setattr(store, "FOLDER", tmp_path)
|
||||
return tmp_path
|
||||
|
||||
|
||||
def _bytes(folder: Path) -> dict[str, bytes]:
|
||||
out = {p.name: p.read_bytes() for p in folder.glob("*.json")}
|
||||
out |= {f"기계/{p.name}": p.read_bytes() for p in (folder / "기계").glob("*.json")}
|
||||
return out
|
||||
|
||||
|
||||
def _new_logic() -> dict:
|
||||
return {
|
||||
"op": "add",
|
||||
"row": {
|
||||
"원문번호": "",
|
||||
"구분": "자체",
|
||||
"상세구분": "",
|
||||
"소유": "현장",
|
||||
"이름": "sub5임시 대장 시험",
|
||||
"결과단위": "원/㎡",
|
||||
"출처": "자체",
|
||||
"입력": [],
|
||||
"중간": [],
|
||||
"호표": [
|
||||
{
|
||||
"종류": "인력",
|
||||
"요소": LABOR,
|
||||
"이름": "보통인부",
|
||||
"단위": "인",
|
||||
"수량": "1 / 7",
|
||||
"비목": "노무비",
|
||||
}
|
||||
],
|
||||
"덧줄": [],
|
||||
"끝수": None,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def _batch() -> list[dict]:
|
||||
"""기계 한 대 고침(기계 폴더) + 자체 로직 새 줄(GX 키 발급 = 대장 바뀜)."""
|
||||
machine = json.loads((store.FOLDER / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8"))
|
||||
machine["비고"] = "sub5임시"
|
||||
return [
|
||||
{
|
||||
"file": "기계.json",
|
||||
"version": store.version("기계.json"),
|
||||
"changes": [{"op": "edit", "key": MACHINE, "row": machine}],
|
||||
},
|
||||
{"file": OWN, "version": store.version(OWN), "changes": [_new_logic()]},
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("fail_at", [0, 1])
|
||||
def test_파일_쓰기가_끊기면_대장과_파일이_저장_전_그대로(
|
||||
master: Path, monkeypatch, fail_at
|
||||
) -> None:
|
||||
before = _bytes(master)
|
||||
real = save_mod._write
|
||||
calls = []
|
||||
|
||||
def broken(name, was, now):
|
||||
calls.append(name)
|
||||
if len(calls) - 1 == fail_at:
|
||||
if fail_at: # 둘째 파일은 쓴 뒤에 끊김(반쯤 쓴 꼴)
|
||||
real(name, was, now)
|
||||
raise OSError("디스크 흉내 실패")
|
||||
return real(name, was, now)
|
||||
|
||||
monkeypatch.setattr(save_mod, "_write", broken)
|
||||
with pytest.raises(OSError):
|
||||
store.save(_batch())
|
||||
after = _bytes(master)
|
||||
assert after == before # 대장 · 기계 · 로직 파일 모두 저장 전 글 그대로
|
||||
assert not list(master.glob(".*.tmp")) and not list((master / "기계").glob(".*.tmp"))
|
||||
|
||||
|
||||
def test_끊김_없으면_대장과_파일이_같이_간다(master: Path) -> None:
|
||||
book_before = store.mk.load_book(master / store.mk.BOOK.name)["다음"].get("GX", 1)
|
||||
store.save(_batch())
|
||||
book = store.mk.load_book(master / store.mk.BOOK.name)
|
||||
keys = [r["키"] for r in json.loads((master / OWN).read_text(encoding="utf-8"))["줄"]]
|
||||
assert f"GX{book_before:06d}" in keys and book["다음"]["GX"] == book_before + 1
|
||||
machine = json.loads((master / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8"))
|
||||
assert machine["비고"] == "sub5임시"
|
||||
@@ -0,0 +1,33 @@
|
||||
"""855-A 지킴 ④ — 막힘 판정 옛(`master_formula.check_logic` · M01 로직 목록 · `/logic`) = 새(수식 문서
|
||||
표지 `master_doc.check`) 전수 · 막힘 기준 = 표지만(기본 입력으로 셈이 안 되는 것은 막힘 아님 · 판정 855-0).
|
||||
|
||||
걸음 2-B3(막힘 검사를 문서 기준으로) 앞뒤로 같아야 함 · 옛 검사를 지우는 걸음에서 옛 쪽만 뗌."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
|
||||
import helper_855_engine as h
|
||||
|
||||
md = importlib.import_module("master_doc")
|
||||
|
||||
|
||||
def test_막힘_옛_새_같음():
|
||||
rows, whole, docs, _ = h.world()
|
||||
old = {str(r["키"]) for r in rows if h.mf.check_logic(whole, r)[0]}
|
||||
new = {str(r["키"]) for r in rows if str(r["키"]) not in docs or md.check(docs[str(r["키"])])}
|
||||
assert old == new, {"옛만 막힘": sorted(old - new)[:20], "새만 막힘": sorted(new - old)[:20]}
|
||||
|
||||
|
||||
def test_틀린_식은_옛_새_모두_막힘():
|
||||
"""자가 살아 있는지 — 같은 로직의 식을 틀리게 하면 두 판정 모두 막힘(사본만 · 자료 안 고침)."""
|
||||
import copy
|
||||
|
||||
rows, whole, docs, _ = h.world()
|
||||
row = next(r for r in rows if r.get("호표") and str(r["키"]) in docs)
|
||||
bad_row = copy.deepcopy(row)
|
||||
bad_row["호표"][0]["수량"] = "없는변수 * 2"
|
||||
bad_doc = copy.deepcopy(docs[str(row["키"])])
|
||||
bad_doc["금액"][0]["수량"] = "없는기호 × 2"
|
||||
assert h.mf.check_logic(whole, bad_row)[0]
|
||||
assert md.check(bad_doc)
|
||||
@@ -0,0 +1,46 @@
|
||||
"""855-A 지킴 ① — 로직 전수 옛 엔진 대 새 계산기(저장된 수식 문서) · 걸음 2 동안 「다름 0」 자.
|
||||
|
||||
- 기본 입력 전수(관문 · 십여 초) · 옵션 표본 전수 = 환경 `S855_ALL=1`(3 분 남짓).
|
||||
- 층 L0 합계 · L1 줄 비목 · L2 줄 꼴 · L3 수량 · 단가(`helper_855_engine.level`).
|
||||
- 다름 = 채택된 차이와 같아야 함(합계 = 빌더 `ADOPTED` 그대로 · 줄 비목 = 같은 까닭의 문서만) ·
|
||||
「보임」(보이는 단가만 · 금액 같음)은 허용 갈래로 셈.
|
||||
- 옛 엔진을 지우는 걸음(2-E4)에서 은퇴 — 그 뒤는 `test_855_golden` 이 지킴.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
|
||||
import helper_855_engine as h
|
||||
|
||||
ALL = os.environ.get("S855_ALL") == "1"
|
||||
|
||||
|
||||
def _diffs(options: bool) -> dict[str, list]:
|
||||
rows, _, docs, _ = h.world()
|
||||
out: dict[str, list] = {"문서 없음": [], "채택 밖": [], "채택": [], h.SEEN: []}
|
||||
for row in rows:
|
||||
key = str(row["키"])
|
||||
doc = docs.get(key)
|
||||
if doc is None:
|
||||
out["문서 없음"].append(key)
|
||||
continue
|
||||
money = not doc.get("결과")
|
||||
for label, given, changed in h.cases(row, options):
|
||||
lv = h.level(h.old_run(row, given), h.new_run(doc, changed), money)
|
||||
if lv == h.SEEN:
|
||||
out[h.SEEN].append((key, label))
|
||||
elif lv and h.adopted(key, label, lv):
|
||||
out["채택"].append((key, label, lv))
|
||||
elif lv:
|
||||
out["채택 밖"].append((key, label, lv))
|
||||
return out
|
||||
|
||||
|
||||
def test_로직마다_수식_문서_있음_옛_대_새_다름은_채택뿐():
|
||||
got = _diffs(ALL)
|
||||
assert got["문서 없음"] == []
|
||||
assert got["채택 밖"] == [], got["채택 밖"][:20]
|
||||
total = {(k, o) for k, o, lv in got["채택"] if lv == "L0"}
|
||||
want = {x for x in h.build.ADOPTED if not x[1]} if not ALL else set(h.build.ADOPTED)
|
||||
assert total == want # 채택 목록이 다 나오고 그 밖은 없음(기본만 돌면 옵션 채택은 안 나옴)
|
||||
@@ -0,0 +1,47 @@
|
||||
"""855-A 지킴 ② — 새 계산기 답 지문(로직마다 기본 + 옵션 표본 · 노 · 재 · 경 · 계 · 줄 금액 · 비목).
|
||||
|
||||
- 지문 = `golden_855_engine.json`(로직 키 → 답 묶음 sha256 앞 16 자 · `helper_855_engine.fingerprint`).
|
||||
- 다르면 실패 — 계산기 · 수식 문서 · M01 자료가 금액을 바꿨다는 뜻. 자료 · 규칙을 **뜻대로 바꾼 걸음만**
|
||||
다시 뜸: `./venv/Scripts/python.exe resources/tester/test_855_golden.py --write`(바뀐 키를 커밋 글에).
|
||||
- 옛 엔진을 지운 뒤(2-E4) 옛 → 새 대조(`test_855_engine_parity` · `test_802_2`)를 이것이 대신함.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
FILE = HERE / "golden_855_engine.json"
|
||||
REDO = "./venv/Scripts/python.exe resources/tester/test_855_golden.py --write"
|
||||
|
||||
|
||||
def current() -> dict[str, str]:
|
||||
import helper_855_engine as h
|
||||
|
||||
rows, _, docs, _ = h.world()
|
||||
return {str(r["키"]): h.fingerprint(str(r["키"]), r) for r in rows if str(r["키"]) in docs}
|
||||
|
||||
|
||||
def test_새_계산기_답_지문_같음():
|
||||
want = json.loads(FILE.read_text("utf-8"))["지문"]
|
||||
got = current()
|
||||
changed = sorted(k for k in want.keys() & got.keys() if want[k] != got[k])
|
||||
gone, new = sorted(want.keys() - got.keys()), sorted(got.keys() - want.keys())
|
||||
assert not (changed or gone or new), (
|
||||
f"지문 다름 — 바뀜 {len(changed)} {changed[:20]} · 빠짐 {gone[:20]} · 새 키 {new[:20]}\n"
|
||||
f"뜻대로 금액을 바꾼 걸음이면 다시 뜸: {REDO} (아니면 고친 코드 · 자료를 되짚음)"
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
ROOT = HERE.parents[1]
|
||||
for p in (str(ROOT), str(HERE)):
|
||||
if p not in sys.path:
|
||||
sys.path.insert(0, p)
|
||||
if "--write" not in sys.argv:
|
||||
sys.exit(f"다시 뜨기 = {REDO}")
|
||||
body = {"판": 1, "지문": dict(sorted(current().items()))}
|
||||
FILE.write_text(json.dumps(body, ensure_ascii=False, indent=1) + "\n", "utf-8", newline="\n")
|
||||
print(f"지문 {len(body['지문'])} 씀 → {FILE.name}")
|
||||
@@ -0,0 +1,125 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""855-A 지킴 ③ — 단가산출(SK) 셈 답 · 견본 꼴마다 옛 엔진 길(`M02_Doc_Sk.OLD`) 대 지금 길(수식 사본 →
|
||||
문서 계산기) · 지금 길 답의 줄 비목 합(원 버림) = 기준.
|
||||
|
||||
견본(임시 storage · 개인 층 · M01 은 읽기만): 바탕 로직 · 옛 칸 값(더한줄 로직) · 율 더한줄 · 형제 SK(바탕 참조) ·
|
||||
「따로」(수식 사본을 고쳐 저장) · 가져온 식(엑셀 줄 · 저장 없음).
|
||||
걸음 2-C1(SK 셈 한 길)이 이 시험을 자로 씀 — 「따로」 단언은 지금 사실(줄 = 옛 · 기준 = 새)이고 2-C1 에서 뒤집음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
from decimal import ROUND_DOWN, Decimal
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Doc_Sk as dsk
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
||||
from resources.tester import test_793_2_sangeun_imported as imported
|
||||
from resources.tester.test_778_4_rate_line import SUB, _rate
|
||||
from resources.tester.test_795_1_sk_copy import PCT, _doc, _sk
|
||||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||||
|
||||
COSTS = ("노무비", "재료비", "경비")
|
||||
FORM = "GC000211" # 합판거푸집
|
||||
ADD = {"종류": "로직", "로직": "GF000089", "수량": 2, "입력값": {}, "이름": "sub6임시 굴착기"}
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _manual(monkeypatch):
|
||||
"""자동 따라옴 끔 — 저장본 그대로 셈(층 꼴만 봄)."""
|
||||
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
|
||||
|
||||
monkeypatch.setattr(renew, "on", lambda: False)
|
||||
|
||||
|
||||
def _run(doc: dict, old: bool) -> dict:
|
||||
whole = m01.loaded()[1]
|
||||
token = dsk.OLD.set(old)
|
||||
try:
|
||||
return calc.run(sd.clean(doc, None, whole), whole)
|
||||
finally:
|
||||
dsk.OLD.reset(token)
|
||||
|
||||
|
||||
def _both(folder, doc) -> tuple[dict, dict]:
|
||||
with store.at(folder):
|
||||
return _run(doc, True), _run(doc, False)
|
||||
|
||||
|
||||
def _lines_sum(got: dict) -> dict:
|
||||
total = {k: Decimal(0) for k in COSTS}
|
||||
for ln in got.get("줄") or []:
|
||||
for k in COSTS:
|
||||
v = (ln.get("비목") or {}).get(k)
|
||||
total[k] += Decimal(str(v)) if v is not None else 0
|
||||
return {k: v.quantize(Decimal(1), ROUND_DOWN) for k, v in total.items()}
|
||||
|
||||
|
||||
def _base(got: dict) -> dict:
|
||||
return {k: Decimal(str(got["기준"][k])).quantize(Decimal(1), ROUND_DOWN) for k in COSTS}
|
||||
|
||||
|
||||
def _same_paths(old: dict, new: dict) -> None:
|
||||
assert old["기준"] is not None and new["기준"] is not None
|
||||
assert {k: Decimal(str(old["기준"][k])) for k in COSTS} == {
|
||||
k: Decimal(str(new["기준"][k])) for k in COSTS
|
||||
}
|
||||
assert _lines_sum(new) == _base(new)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"body",
|
||||
[
|
||||
{"바탕": {"로직": FORM}},
|
||||
{"바탕": {"로직": PCT}},
|
||||
{"바탕": {"로직": FORM}, "더한줄": [ADD]}, # 옛 칸 값(더한줄 로직)
|
||||
{"바탕": {"로직": SUB}, "더한줄": [_rate("인력", 2)], "단위": "주"}, # 율 더한줄
|
||||
],
|
||||
ids=["바탕", "율_바탕", "옛칸_더한줄", "율_더한줄"],
|
||||
)
|
||||
def test_층_SK_옛_대_새_같고_줄_합_기준(world, body):
|
||||
me = world["personal"]
|
||||
key = _sk(me, **copy.deepcopy(body))
|
||||
doc = _doc(me, key)
|
||||
old, new = _both(me, doc)
|
||||
assert "수식셈" in new # 지금 길 = 수식 사본 문서 셈
|
||||
_same_paths(old, new)
|
||||
|
||||
|
||||
def test_형제_SK_바탕_참조(world):
|
||||
me = world["personal"]
|
||||
first = _sk(me, 바탕={"로직": FORM})
|
||||
second = _sk(me, 바탕={"참조": {"층": "personal", "주인": "7/42", "키": first}})
|
||||
old, new = _both(me, _doc(me, second))
|
||||
_same_paths(old, new)
|
||||
assert new["기준"] == _both(me, _doc(me, first))[1]["기준"]
|
||||
|
||||
|
||||
def test_가져온_식_옛_대_새(world):
|
||||
old, new = _both(world["personal"], imported._doc())
|
||||
assert "수식셈" in new
|
||||
_same_paths(old, new)
|
||||
|
||||
|
||||
def test_따로_SK_지금은_줄_옛_기준_새(world):
|
||||
"""「따로」 = 고친 수식 사본이 정본 — 지금 셈 답은 줄 = 옛 엔진(옛 칸) · 기준 = 문서 계산기라 갈림.
|
||||
2-C1 에서 뒤집을 단언 — 그 뒤엔 `_same_paths` 꼴(줄 합 = 기준)로 바꿈."""
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": PCT})
|
||||
with store.at(me):
|
||||
read = path.read(key)
|
||||
twice = copy.deepcopy(read["문서"])
|
||||
line = twice["금액"][0]
|
||||
line["수량"] = f"({line.get('수량') or 1}) × 2"
|
||||
saved = path.save(key, {"문서": twice, "판": read["판"]})
|
||||
assert saved["사본"]["따로"] is True
|
||||
old, new = _both(me, _doc(me, key))
|
||||
assert new["수식셈"]["따로"] is True
|
||||
assert _base(new) != _base(old) # 2-C1 에서 뒤집을 단언 — 기준이 옛 길과 다름
|
||||
assert _lines_sum(new) == _base(old) != _base(new) # 2-C1 에서 뒤집을 단언 — 줄 = 옛 길
|
||||
Reference in New Issue
Block a user